contrib/binutils-2.20/gold/incremental.cc

   1 // inremental.cc -- incremental linking support for gold
   2
   3 // Copyright 2009 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
  27 #include "elfcpp.h"
  28 #include "output.h"
  29 #include "incremental.h"
  30 #include "archive.h"
  31 #include "output.h"
  32 #include "target-select.h"
  33
  34 using elfcpp::Convert;
  35
  36 namespace gold {
  37
  38 // Version information. Will change frequently during the development, later
  39 // we could think about backward (and forward?) compatibility.
  40 const unsigned int INCREMENTAL_LINK_VERSION = 1;
  41
  42 namespace internal {
  43
  44 // Header of the .gnu_incremental_input section.
  45 struct Incremental_inputs_header_data
  46 {
  47   // Incremental linker version.
  48   elfcpp::Elf_Word version;
  49
  50   // Numer of input files in the link.
  51   elfcpp::Elf_Word input_file_count;
  52
  53   // Offset of command line options in .gnu_incremental_strtab.
  54   elfcpp::Elf_Word command_line_offset;
  55
  56   // Padding.
  57   elfcpp::Elf_Word reserved;
  58 };
  59
  60 // Data stored in .gnu_incremental_input after the header for each of the
  61 // Incremental_input_header_data::input_file_count input entries.
  62 struct Incremental_inputs_entry_data
  63 {
  64   // Offset of file name in .gnu_incremental_strtab section.
  65   elfcpp::Elf_Word filename_offset;
  66
  67   // Offset of data in .gnu_incremental_input.
  68   elfcpp::Elf_Word data_offset;
  69
  70   // Timestamp (in seconds).
  71   elfcpp::Elf_Xword timestamp_sec;
  72
  73   // Nano-second part of timestamp (if supported).
  74   elfcpp::Elf_Word timestamp_nsec;
  75
  76   // Type of the input entry.
  77   elfcpp::Elf_Half input_type;
  78
  79   // Padding.
  80   elfcpp::Elf_Half reserved;
  81 };
  82
  83 }
  84
  85 // Accessors.
  86
  87 // Reader class for .gnu_incremental_inputs header. See
  88 // internal::Incremental_input_header for fields descriptions.
  89
  90 template<int size, bool big_endian>
  91 class Incremental_inputs_header
  92 {
  93  public:
  94   Incremental_inputs_header(const unsigned char *p)
  95     : p_(reinterpret_cast<const internal::Incremental_inputs_header_data*>(p))
  96   { }
  97
  98   static const int data_size = sizeof(internal::Incremental_inputs_header_data);
  99
 100   elfcpp::Elf_Word
 101   get_version() const
 102   { return Convert<32, big_endian>::convert_host(this->p_->version); }
 103
 104   elfcpp::Elf_Word
 105   get_input_file_count() const
 106   { return Convert<32, big_endian>::convert_host(this->p_->input_file_count); }
 107
 108   elfcpp::Elf_Word
 109   get_command_line_offset() const
 110   { return Convert<32, big_endian>::convert_host(this->p_->command_line_offset); }
 111
 112   elfcpp::Elf_Word
 113   get_reserved() const
 114   { return Convert<32, big_endian>::convert_host(this->p_->reserved); }
 115
 116  private:
 117   const internal::Incremental_inputs_header_data* p_;
 118 };
 119
 120 // Writer class for .gnu_incremental_inputs header. See
 121 // internal::Incremental_input_header for fields descriptions.
 122
 123 template<int size, bool big_endian>
 124 class Incremental_inputs_header_write
 125 {
 126  public:
 127   Incremental_inputs_header_write(unsigned char *p)
 128     : p_(reinterpret_cast<internal::Incremental_inputs_header_data*>(p))
 129   { }
 130
 131   static const int data_size = sizeof(internal::Incremental_inputs_header_data);
 132
 133   void
 134   put_version(elfcpp::Elf_Word v)
 135   { this->p_->version = Convert<32, big_endian>::convert_host(v); }
 136
 137   void
 138   put_input_file_count(elfcpp::Elf_Word v)
 139   { this->p_->input_file_count = Convert<32, big_endian>::convert_host(v); }
 140
 141   void
 142   put_command_line_offset(elfcpp::Elf_Word v)
 143   { this->p_->command_line_offset = Convert<32, big_endian>::convert_host(v); }
 144
 145   void
 146   put_reserved(elfcpp::Elf_Word v)
 147   { this->p_->reserved = Convert<32, big_endian>::convert_host(v); }
 148
 149  private:
 150   internal::Incremental_inputs_header_data* p_;
 151 };
 152
 153 // Reader class for an .gnu_incremental_inputs entry. See
 154 // internal::Incremental_input_entry for fields descriptions.
 155 template<int size, bool big_endian>
 156 class Incremental_inputs_entry
 157 {
 158  public:
 159   Incremental_inputs_entry(const unsigned char *p)
 160     : p_(reinterpret_cast<const internal::Incremental_inputs_entry_data*>(p))
 161   { }
 162
 163   static const int data_size = sizeof(internal::Incremental_inputs_entry_data);
 164
 165   elfcpp::Elf_Word
 166   get_filename_offset(elfcpp::Elf_Word v)
 167   { return Convert<32, big_endian>::convert_host(this->p_->filename_offset); }
 168
 169   elfcpp::Elf_Word
 170   get_data_offset(elfcpp::Elf_Word v)
 171   { return Convert<32, big_endian>::convert_host(this->p_->data_offset); }
 172
 173   elfcpp::Elf_Xword
 174   get_timestamp_sec(elfcpp::Elf_Xword v)
 175   { return Convert<64, big_endian>::convert_host(this->p_->timestamp_sec); }
 176
 177   elfcpp::Elf_Word
 178   get_timestamp_nsec(elfcpp::Elf_Word v)
 179   { return Convert<32, big_endian>::convert_host(this->p_->timestamp_nsec); }
 180
 181   elfcpp::Elf_Word
 182   get_input_type(elfcpp::Elf_Word v)
 183   { return Convert<32, big_endian>::convert_host(this->p_->input_type); }
 184
 185   elfcpp::Elf_Word
 186   get_reserved(elfcpp::Elf_Word v)
 187   { return Convert<32, big_endian>::convert_host(this->p_->reserved); }
 188
 189  private:
 190   const internal::Incremental_inputs_entry_data* p_;
 191 };
 192
 193 // Writer class for an .gnu_incremental_inputs entry. See
 194 // internal::Incremental_input_entry for fields descriptions.
 195 template<int size, bool big_endian>
 196 class Incremental_inputs_entry_write
 197 {
 198  public:
 199   Incremental_inputs_entry_write(unsigned char *p)
 200     : p_(reinterpret_cast<internal::Incremental_inputs_entry_data*>(p))
 201   { }
 202
 203   static const int data_size = sizeof(internal::Incremental_inputs_entry_data);
 204
 205   void
 206   put_filename_offset(elfcpp::Elf_Word v)
 207   { this->p_->filename_offset = Convert<32, big_endian>::convert_host(v); }
 208
 209   void
 210   put_data_offset(elfcpp::Elf_Word v)
 211   { this->p_->data_offset = Convert<32, big_endian>::convert_host(v); }
 212
 213   void
 214   put_timestamp_sec(elfcpp::Elf_Xword v)
 215   { this->p_->timestamp_sec = Convert<64, big_endian>::convert_host(v); }
 216
 217   void
 218   put_timestamp_nsec(elfcpp::Elf_Word v)
 219   { this->p_->timestamp_nsec = Convert<32, big_endian>::convert_host(v); }
 220
 221   void
 222   put_input_type(elfcpp::Elf_Word v)
 223   { this->p_->input_type = Convert<32, big_endian>::convert_host(v); }
 224
 225   void
 226   put_reserved(elfcpp::Elf_Word v)
 227   { this->p_->reserved = Convert<32, big_endian>::convert_host(v); }
 228
 229  private:
 230   internal::Incremental_inputs_entry_data* p_;
 231 };
 232
 233 // Inform the user why we don't do an incremental link.  Not called in
 234 // the obvious case of missing output file.  TODO: Is this helpful?
 235
 236 void
 237 vexplain_no_incremental(const char* format, va_list args)
 238 {
 239   char* buf = NULL;
 240   if (vasprintf(&buf, format, args) < 0)
 241     gold_nomem();
 242   gold_info(_("the link might take longer: "
 243               "cannot perform incremental link: %s"), buf);
 244   free(buf);
 245 }
 246
 247 void
 248 explain_no_incremental(const char* format, ...)
 249 {
 250   va_list args;
 251   va_start(args, format);
 252   vexplain_no_incremental(format, args);
 253   va_end(args);
 254 }
 255
 256 // Report an error.
 257
 258 void
 259 Incremental_binary::error(const char* format, ...) const
 260 {
 261   va_list args;
 262   va_start(args, format);
 263   // Current code only checks if the file can be used for incremental linking,
 264   // so errors shouldn't fail the build, but only result in a fallback to a
 265   // full build.
 266   // TODO: when we implement incremental editing of the file, we may need a
 267   // flag that will cause errors to be treated seriously.
 268   vexplain_no_incremental(format, args);
 269   va_end(args);
 270 }
 271
 272 template<int size, bool big_endian>
 273 bool
 274 Sized_incremental_binary<size, big_endian>::do_find_incremental_inputs_section(
 275     Location* location,
 276     unsigned int* strtab_shndx)
 277 {
 278   unsigned int shndx = this->elf_file_.find_section_by_type(
 279       elfcpp::SHT_GNU_INCREMENTAL_INPUTS);
 280   if (shndx == elfcpp::SHN_UNDEF)  // Not found.
 281     return false;
 282   *strtab_shndx = this->elf_file_.section_link(shndx);
 283   *location = this->elf_file_.section_contents(shndx);
 284   return true;
 285 }
 286
 287 template<int size, bool big_endian>
 288 bool
 289 Sized_incremental_binary<size, big_endian>::do_check_inputs(
 290     Incremental_inputs* incremental_inputs)
 291 {
 292   const int entry_size =
 293       Incremental_inputs_entry_write<size, big_endian>::data_size;
 294   const int header_size =
 295       Incremental_inputs_header_write<size, big_endian>::data_size;
 296
 297   unsigned int strtab_shndx;
 298   Location location;
 299
 300   if (!do_find_incremental_inputs_section(&location, &strtab_shndx))
 301     {
 302       explain_no_incremental(_("no incremental data from previous build"));
 303       return false;
 304     }
 305   if (location.data_size < header_size
 306       || strtab_shndx >= this->elf_file_.shnum()
 307       || this->elf_file_.section_type(strtab_shndx) != elfcpp::SHT_STRTAB)
 308     {
 309       explain_no_incremental(_("invalid incremental build data"));
 310       return false;
 311     }
 312
 313   Location strtab_location(this->elf_file_.section_contents(strtab_shndx));
 314   View data_view(view(location));
 315   View strtab_view(view(strtab_location));
 316   elfcpp::Elf_strtab strtab(strtab_view.data(), strtab_location.data_size);
 317   Incremental_inputs_header<size, big_endian> header(data_view.data());
 318
 319   if (header.get_version() != INCREMENTAL_LINK_VERSION)
 320     {
 321       explain_no_incremental(_("different version of incremental build data"));
 322       return false;
 323     }
 324
 325   const char* command_line;
 326   // We divide instead of multiplying to make sure there is no integer
 327   // overflow.
 328   size_t max_input_entries = (location.data_size - header_size) / entry_size;
 329   if (header.get_input_file_count() > max_input_entries
 330       || !strtab.get_c_string(header.get_command_line_offset(), &command_line))
 331     {
 332       explain_no_incremental(_("invalid incremental build data"));
 333       return false;
 334     }
 335
 336   if (incremental_inputs->command_line() != command_line)
 337     {
 338       explain_no_incremental(_("command line changed"));
 339       return false;
 340     }
 341
 342   // TODO: compare incremental_inputs->inputs() with entries in data_view.
 343   return true;
 344 }
 345
 346 namespace
 347 {
 348
 349 // Create a Sized_incremental_binary object of the specified size and
 350 // endianness. Fails if the target architecture is not supported.
 351
 352 template<int size, bool big_endian>
 353 Incremental_binary*
 354 make_sized_incremental_binary(Output_file* file,
 355                               const elfcpp::Ehdr<size, big_endian>& ehdr)
 356 {
 357   Target* target = select_target(ehdr.get_e_machine(), size, big_endian,
 358                                  ehdr.get_e_ident()[elfcpp::EI_OSABI],
 359                                  ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]);
 360   if (target == NULL)
 361     {
 362       explain_no_incremental(_("unsupported ELF machine number %d"),
 363                ehdr.get_e_machine());
 364       return NULL;
 365     }
 366
 367   return new Sized_incremental_binary<size, big_endian>(file, ehdr, target);
 368 }
 369
 370 }  // End of anonymous namespace.
 371
 372 // Create an Incremental_binary object for FILE. Returns NULL is this is not
 373 // possible, e.g. FILE is not an ELF file or has an unsupported target. FILE
 374 // should be opened.
 375
 376 Incremental_binary*
 377 open_incremental_binary(Output_file* file)
 378 {
 379   off_t filesize = file->filesize();
 380   int want = elfcpp::Elf_recognizer::max_header_size;
 381   if (filesize < want)
 382     want = filesize;
 383
 384   const unsigned char* p = file->get_input_view(0, want);
 385   if (!elfcpp::Elf_recognizer::is_elf_file(p, want))
 386     {
 387       explain_no_incremental(_("output is not an ELF file."));
 388       return NULL;
 389     }
 390
 391   int size;
 392   bool big_endian;
 393   std::string error;
 394   if (!elfcpp::Elf_recognizer::is_valid_header(p, want, &size, &big_endian,
 395                                                &error))
 396     {
 397       explain_no_incremental(error.c_str());
 398       return NULL;
 399     }
 400
 401   Incremental_binary* result = NULL;
 402   if (size == 32)
 403     {
 404       if (big_endian)
 405         {
 406 #ifdef HAVE_TARGET_32_BIG
 407           result = make_sized_incremental_binary<32, true>(
 408               file, elfcpp::Ehdr<32, true>(p));
 409 #else
 410           explain_no_incremental(_("unsupported file: 32-bit, big-endian"));
 411 #endif
 412         }
 413       else
 414         {
 415 #ifdef HAVE_TARGET_32_LITTLE
 416           result = make_sized_incremental_binary<32, false>(
 417               file, elfcpp::Ehdr<32, false>(p));
 418 #else
 419           explain_no_incremental(_("unsupported file: 32-bit, little-endian"));
 420 #endif
 421         }
 422     }
 423   else if (size == 64)
 424     {
 425       if (big_endian)
 426         {
 427 #ifdef HAVE_TARGET_64_BIG
 428           result = make_sized_incremental_binary<64, true>(
 429               file, elfcpp::Ehdr<64, true>(p));
 430 #else
 431           explain_no_incremental(_("unsupported file: 64-bit, big-endian"));
 432 #endif
 433         }
 434       else
 435         {
 436 #ifdef HAVE_TARGET_64_LITTLE
 437           result = make_sized_incremental_binary<64, false>(
 438               file, elfcpp::Ehdr<64, false>(p));
 439 #else
 440           explain_no_incremental(_("unsupported file: 64-bit, little-endian"));
 441 #endif
 442         }
 443     }
 444   else
 445     gold_unreachable();
 446
 447   return result;
 448 }
 449
 450 // Analyzes the output file to check if incremental linking is possible and
 451 // (to be done) what files need to be relinked.
 452
 453 bool
 454 Incremental_checker::can_incrementally_link_output_file()
 455 {
 456   Output_file output(this->output_name_);
 457   if (!output.open_for_modification())
 458     return false;
 459   Incremental_binary* binary = open_incremental_binary(&output);
 460   if (binary == NULL)
 461     return false;
 462   return binary->check_inputs(this->incremental_inputs_);
 463 }
 464
 465 // Add the command line to the string table, setting
 466 // command_line_key_.  In incremental builds, the command line is
 467 // stored in .gnu_incremental_inputs so that the next linker run can
 468 // check if the command line options didn't change.
 469
 470 void
 471 Incremental_inputs::report_command_line(int argc, const char* const* argv)
 472 {
 473   // Always store 'gold' as argv[0] to avoid a full relink if the user used a
 474   // different path to the linker.
 475   std::string args("gold");
 476   // Copied from collect_argv in main.cc.
 477   for (int i = 1; i < argc; ++i)
 478     {
 479       // Adding/removing these options should result in a full relink.
 480       if (strcmp(argv[i], "--incremental-changed") == 0
 481           || strcmp(argv[i], "--incremental-unchanged") == 0
 482           || strcmp(argv[i], "--incremental-unknown") == 0)
 483         continue;
 484
 485       args.append(" '");
 486       // Now append argv[i], but with all single-quotes escaped
 487       const char* argpos = argv[i];
 488       while (1)
 489         {
 490           const int len = strcspn(argpos, "'");
 491           args.append(argpos, len);
 492           if (argpos[len] == '\0')
 493             break;
 494           args.append("'\"'\"'");
 495           argpos += len + 1;
 496         }
 497       args.append("'");
 498     }
 499
 500   this->command_line_ = args;
 501   this->strtab_->add(this->command_line_.c_str(), false,
 502                      &this->command_line_key_);
 503 }
 504
 505 // Record that the input argument INPUT is an achive ARCHIVE.  This is
 506 // called by Read_symbols after finding out the type of the file.
 507
 508 void
 509 Incremental_inputs::report_archive(const Input_argument* input,
 510                                    Archive* archive)
 511 {
 512   Hold_lock hl(*this->lock_);
 513
 514   Input_info info;
 515   info.type = INCREMENTAL_INPUT_ARCHIVE;
 516   info.archive = archive;
 517   info.mtime = archive->file().get_mtime();
 518   this->inputs_map_.insert(std::make_pair(input, info));
 519 }
 520
 521 // Record that the input argument INPUT is an object OBJ.  This is
 522 // called by Read_symbols after finding out the type of the file.
 523
 524 void
 525 Incremental_inputs::report_object(const Input_argument* input,
 526                                   Object* obj)
 527 {
 528   Hold_lock hl(*this->lock_);
 529
 530   Input_info info;
 531   info.type = (obj->is_dynamic()
 532                ? INCREMENTAL_INPUT_SHARED_LIBRARY
 533                : INCREMENTAL_INPUT_OBJECT);
 534   info.object = obj;
 535   info.mtime = obj->input_file()->file().get_mtime();
 536   this->inputs_map_.insert(std::make_pair(input, info));
 537 }
 538
 539 // Record that the input argument INPUT is an script SCRIPT.  This is
 540 // called by read_script after parsing the script and reading the list
 541 // of inputs added by this script.
 542
 543 void
 544 Incremental_inputs::report_script(const Input_argument* input,
 545                                   Timespec mtime,
 546                                   Script_info* script)
 547 {
 548   Hold_lock hl(*this->lock_);
 549
 550   Input_info info;
 551   info.type = INCREMENTAL_INPUT_SCRIPT;
 552   info.script = script;
 553   info.mtime = mtime;
 554   this->inputs_map_.insert(std::make_pair(input, info));
 555 }
 556
 557 // Compute indexes in the order in which the inputs should appear in
 558 // .gnu_incremental_inputs.  This needs to be done after all the
 559 // scripts are parsed.  The function is first called for the command
 560 // line inputs arguments and may call itself recursively for e.g. a
 561 // list of elements of a group or a list of inputs added by a script.
 562 // The [BEGIN; END) interval to analyze and *INDEX is the current
 563 // value of the index (that will be updated).
 564
 565 void
 566 Incremental_inputs::finalize_inputs(
 567     Input_argument_list::const_iterator begin,
 568     Input_argument_list::const_iterator end,
 569     unsigned int* index)
 570 {
 571   for (Input_argument_list::const_iterator p = begin; p != end; ++p)
 572     {
 573       if (p->is_group())
 574         {
 575           finalize_inputs(p->group()->begin(), p->group()->end(), index);
 576           continue;
 577         }
 578
 579       Inputs_info_map::iterator it = this->inputs_map_.find(&(*p));
 580       // TODO: turn it into an assert when the code will be more stable.
 581       if (it == this->inputs_map_.end())
 582         {
 583           gold_error("internal error: %s: incremental build info not provided",
 584                      (p->is_file() ? p->file().name() : "[group]"));
 585           continue;
 586         }
 587       Input_info* info = &it->second;
 588       info->index = *index;
 589       (*index)++;
 590       this->strtab_->add(p->file().name(), false, &info->filename_key);
 591       if (info->type == INCREMENTAL_INPUT_SCRIPT)
 592         {
 593           finalize_inputs(info->script->inputs()->begin(),
 594                           info->script->inputs()->end(),
 595                           index);
 596         }
 597     }
 598 }
 599
 600 // Finalize the incremental link information.  Called from
 601 // Layout::finalize.
 602
 603 void
 604 Incremental_inputs::finalize()
 605 {
 606   unsigned int index = 0;
 607   finalize_inputs(this->inputs_->begin(), this->inputs_->end(), &index);
 608
 609   // Sanity check.
 610   for (Inputs_info_map::const_iterator p = this->inputs_map_.begin();
 611        p != this->inputs_map_.end();
 612        ++p)
 613     {
 614       gold_assert(p->second.filename_key != 0);
 615     }
 616
 617   this->strtab_->set_string_offsets();
 618 }
 619
 620 // Create the content of the .gnu_incremental_inputs section.
 621
 622 Output_section_data*
 623 Incremental_inputs::create_incremental_inputs_section_data()
 624 {
 625   switch (parameters->size_and_endianness())
 626     {
 627 #ifdef HAVE_TARGET_32_LITTLE
 628     case Parameters::TARGET_32_LITTLE:
 629       return this->sized_create_inputs_section_data<32, false>();
 630 #endif
 631 #ifdef HAVE_TARGET_32_BIG
 632     case Parameters::TARGET_32_BIG:
 633       return this->sized_create_inputs_section_data<32, true>();
 634 #endif
 635 #ifdef HAVE_TARGET_64_LITTLE
 636     case Parameters::TARGET_64_LITTLE:
 637       return this->sized_create_inputs_section_data<64, false>();
 638 #endif
 639 #ifdef HAVE_TARGET_64_BIG
 640     case Parameters::TARGET_64_BIG:
 641       return this->sized_create_inputs_section_data<64, true>();
 642 #endif
 643     default:
 644       gold_unreachable();
 645     }
 646 }
 647
 648 // Sized creation of .gnu_incremental_inputs section.
 649
 650 template<int size, bool big_endian>
 651 Output_section_data*
 652 Incremental_inputs::sized_create_inputs_section_data()
 653 {
 654   const int entry_size =
 655       Incremental_inputs_entry_write<size, big_endian>::data_size;
 656   const int header_size =
 657       Incremental_inputs_header_write<size, big_endian>::data_size;
 658
 659   unsigned int sz = header_size + entry_size * this->inputs_map_.size();
 660   unsigned char* buffer = new unsigned char[sz];
 661   unsigned char* inputs_base = buffer + header_size;
 662
 663   Incremental_inputs_header_write<size, big_endian> header_writer(buffer);
 664   gold_assert(this->command_line_key_ > 0);
 665   int cmd_offset = this->strtab_->get_offset_from_key(this->command_line_key_);
 666
 667   header_writer.put_version(INCREMENTAL_LINK_VERSION);
 668   header_writer.put_input_file_count(this->inputs_map_.size());
 669   header_writer.put_command_line_offset(cmd_offset);
 670   header_writer.put_reserved(0);
 671
 672   for (Inputs_info_map::const_iterator it = this->inputs_map_.begin();
 673        it != this->inputs_map_.end();
 674        ++it)
 675     {
 676       gold_assert(it->second.index < this->inputs_map_.size());
 677
 678       unsigned char* entry_buffer =
 679           inputs_base + it->second.index * entry_size;
 680       Incremental_inputs_entry_write<size, big_endian> entry(entry_buffer);
 681       int filename_offset =
 682           this->strtab_->get_offset_from_key(it->second.filename_key);
 683       entry.put_filename_offset(filename_offset);
 684       // TODO: add per input data and timestamp.  Currently we store
 685       // an out-of-bounds offset for future version of gold to reject
 686       // such an incremental_inputs section.
 687       entry.put_data_offset(0xffffffff);
 688       entry.put_timestamp_sec(it->second.mtime.seconds);
 689       entry.put_timestamp_nsec(it->second.mtime.nanoseconds);
 690       entry.put_input_type(it->second.type);
 691       entry.put_reserved(0);
 692     }
 693
 694   return new Output_data_const_buffer(buffer, sz, 8,
 695                                       "** incremental link inputs list");
 696 }
 697
 698 // Instantiate the templates we need.
 699
 700 #ifdef HAVE_TARGET_32_LITTLE
 701 template
 702 class Sized_incremental_binary<32, false>;
 703 #endif
 704
 705 #ifdef HAVE_TARGET_32_BIG
 706 template
 707 class Sized_incremental_binary<32, true>;
 708 #endif
 709
 710 #ifdef HAVE_TARGET_64_LITTLE
 711 template
 712 class Sized_incremental_binary<64, false>;
 713 #endif
 714
 715 #ifdef HAVE_TARGET_64_BIG
 716 template
 717 class Sized_incremental_binary<64, true>;
 718 #endif
 719
 720 } // End namespace gold.