elfcpp/ChangeLog:

	* elfcpp.h (enum SHT): Add SHT_GNU_INCREMENTAL_SYMTAB,
	SHT_GNU_INCREMENTAL_RELOCS.

gold/ChangeLog:

	* archive.cc: Include incremental.h.
	(Archive::Archive): Initialize incremental_info_.
	(Archive::include_member): Record archive members in incremental info.
	(Add_archive_symbols::run): Record begin and end of an archive in
	incremental info.
	(Lib_group::include_member): Record objects in incremental info.
	* archive.h (Incremental_archive_entry): Forward declaration.
	(Archive::set_incremental_info): New member function.
	(Archive::incremental_info): New member function.
	(Archive::Unused_symbol_iterator): New class.
	(Archive::unused_symbols_begin): New member function.
	(Archive::unused_symbols_end): New member function.
	(Archive::incremental_info_): New data member.
	* incremental-dump.cc (find_input_containing_global): New function.
	(dump_incremental_inputs): Dump new incremental info sections.
	* incremental.cc: Include symtab.h.
	(Output_section_incremental_inputs): New class.
	(Sized_incremental_binary::do_find_incremental_inputs_sections): Support
	new incremental info sections.
	(Sized_incremental_binary::do_check_inputs): Likewise.
	(Incremental_inputs::report_archive): Remove.
	(Incremental_inputs::report_archive_begin): New function.
	(Incremental_inputs::report_archive_end): New function.
	(Incremental_inputs::report_object): New function.
	(Incremental_inputs::finalize_inputs): Remove.
	(Incremental_inputs::report_input_section): New function.
	(Incremental_inputs::report_script): Rewrite.
	(Incremental_inputs::finalize): Do nothing but finalize string table.
	(Incremental_inputs::create_incremental_inputs_section_data): Remove.
	(Incremental_inputs::sized_create_inputs_section_data): Remove.
	(Incremental_inputs::create_data_sections): New function.
	(Incremental_inputs::relocs_entsize): New function.
	(Output_section_incremental_inputs::set_final_data_size): New function.
	(Output_section_incremental_inputs::do_write): New function.
	(Output_section_incremental_inputs::write_header): New function.
	(Output_section_incremental_inputs::write_input_files): New function.
	(Output_section_incremental_inputs::write_info_blocks): New function.
	(Output_section_incremental_inputs::write_symtab): New function.
	* incremental.h (Incremental_script_entry): Forward declaration.
	(Incremental_object_entry): Forward declaration.
	(Incremental_archive_entry): Forward declaration.
	(Incremental_inputs): Forward declaration.
	(Incremental_inputs_header_data): Remove.
	(Incremental_inputs_header): Remove.
	(Incremental_inputs_header_write): Remove.
	(Incremental_inputs_entry_data): Remove.
	(Incremental_inputs_entry): Remove.
	(Incremental_inputs_entry_write): Remove.
	(enum Incremental_input_type): Add INCREMENTAL_INPUT_ARCHIVE_MEMBER.
	(Incremental_binary::find_incremental_inputs_sections): Add parameters.
	(Incremental_binary::do_find_incremental_inputs_sections): Likewise.
	(Sized_ncremental_binary::do_find_incremental_inputs_sections):
	Likewise.
	(Incremental_input_entry): New class.
	(Incremental_script_entry): New class.
	(Incremental_object_entry): New class.
	(Incremental_archive_entry): New class.
	(Incremental_inputs::Incremental_inputs): Initialize new data members.
	(Incremental_inputs::report_inputs): Remove.
	(Incremental_inputs::report_archive): Remove.
	(Incremental_inputs::report_archive_begin): New function.
	(Incremental_inputs::report_archive_end): New function.
	(Incremental_inputs::report_object): Change prototype.
	(Incremental_inputs::report_input_section): New function.
	(Incremental_inputs::report_script): Change prototype.
	(Incremental_inputs::get_reloc_count): New function.
	(Incremental_inputs::set_reloc_count): New function.
	(Incremental_inputs::create_data_sections): New function.
	(Incremental_inputs::create_incremental_inputs_section_data): Remove.
	(Incremental_inputs::inputs_section): New function.
	(Incremental_inputs::symtab_section): New function.
	(Incremental_inputs::relocs_section): New function.
	(Incremental_inputs::get_stringpool): Add const.
	(Incremental_inputs::command_line): Add const.
	(Incremental_inputs::inputs): Remove.
	(Incremental_inputs::command_line_key): New function.
	(Incremental_inputs::input_file_count): New function.
	(Incremental_inputs::input_files): New function.
	(Incremental_inputs::relocs_entsize): New function.
	(Incremental_inputs::sized_create_inputs_section_data): Remove.
	(Incremental_inputs::finalize_inputs): Remove.
	(Incremental_inputs::Input_info): Remove.
	(Incremental_inputs::lock_): Remove.
	(Incremental_inputs::inputs_): Change type.
	(Incremental_inputs::inputs_map_): Remove.
	(Incremental_inputs::current_object_entry_): New data member.
	(Incremental_inputs::inputs_section_): New data member.
	(Incremental_inputs::symtab_section_): New data member.
	(Incremental_inputs::relocs_section_): New data member.
	(Incremental_inputs::reloc_count_): New data member.
	(Incremental_inputs_reader): New class.
	(Incremental_symtab_reader): New class.
	(Incremental_relocs_reader): New class.
	* layout.cc (Layout::finalize): Move finalization of incremental info
	and creation of incremental info sections to follow finalization of
	symbol table.  Set offsets for postprocessing sections.
	(Layout::create_incremental_info_sections): Call
	Incremental_inputs::create_data_sections.  Add incremental symtab
	and relocs sections.  Set sh_entsize and sh_link fields.  Arrange for
	sections to layout after input sections.
	* layout.h (struct Timespec): Forward declaration.
	(Layout::incremental_inputs): Add const.
	(Layout::create_incremental_info_sections): Add parameter.
	* main.cc (main): Remove call to Incremental_inputs::report_inputs.
	* object.cc: Include incremental.h.
	(Relobj::finalize_incremental_relocs): New function.
	(Sized_relobj::do_layout): Record input sections in incremental info.
	* object.h (Object::output_section): New function.
	(Object::output_section_offset): Moved from Relobj.
	(Object::get_incremental_reloc_base): New function.
	(Object::get_incremental_reloc_count): New function.
	(Object::do_output_section): New function.
	(Object::do_output_section_offset): Moved from Relobj.
	(Object::do_get_incremental_reloc_base): New function.
	(Object::do_get_incremental_reloc_count): New function.
	(Object::Object): Initialize new data members.
	(Relobj::output_section): Renamed do_output_section and moved to
	protected.
	(Relobj::output_section_offset): Moved to Object.
	(Relobj::do_get_incremental_reloc_base): New function.
	(Relobj::do_get_incremental_reloc_count): New function.
	(Relobj::allocate_incremental_reloc_counts): New function.
	(Relobj::count_incremental_reloc): New function.
	(Relobj::finalize_incremental_relocs): New function.
	(Relobj::next_incremental_reloc_index): New function.
	(Relobj::reloc_counts_): New data member.
	(Relobj::reloc_bases_): New data member.
	(Sized_relobj::do_relocate_sections): Add parameter.  Change caller.
	(Sized_relobj::relocate_sections): Add parameter.  Change all callers.
	(Sized_relobj::incremental_relocs_scan): New function.
	(Sized_relobj::incremental_relocs_scan_reltype): New function.
	(Sized_relobj::incremental_relocs_write): New function.
	(Sized_relobj::incremental_relocs_write_reltype): New function.
	* plugin.cc (Plugin_manager::add_input_file): Rewrite test for
	incremental link.
	* readsyms.cc (Read_symbols::do_read_symbols): Move reporting of
	archives and object files elsewhere.
	(Add_symbols::run): Report object files here.
	(Finish_group::run): Report end of archive at end of group.
	* reloc.cc: Include layout.h, incremental.h.
	(Sized_relobj::do_read_relocs): Need relocations for incremental link.
	(Sized_relobj::do_scan_relocs): Record relocations for incremental link.
	(Sized_relobj::incremental_relocs_scan): New function.
	(Sized_relobj::incremental_relocs_scan_reltype): New function.
	(Sized_relobj::do_relocate_sections): Write incremental relocations.
	(Sized_relobj::incremental_relocs_write): New function.
	(Sized_relobj::incremental_relocs_write_reltype): New function.
	* script.cc (read_input_script): Rewrite test for incremental link.
	Change call to Incremental_inputs::report_script.
	* symtab.h (Symbol_table::first_global_index): New function.
	(Symbol_table::output_count): New function.

1 files changed, 321 insertions, 83 deletions

diff --git a/gold/incremental-dump.cc b/gold/incremental-dump.cc
index e174b99..98555cd 100644
--- a/gold/incremental-dump.cc
+++ b/gold/incremental-dump.cc
@@ -1,6 +1,6 @@
-// inremental.cc -- incremental linking test/deubg tool
+// incremental.cc -- incremental linking test/debug tool
 
-// Copyright 2009 Free Software Foundation, Inc.
+// Copyright 2009, 2010 Free Software Foundation, Inc.
 // Written by Rafael Avila de Espindola <rafael.espindola@gmail.com>
 
 // This file is part of gold.
@@ -32,6 +32,7 @@
 
 #include <stdio.h>
 #include <errno.h>
+#include <time.h>
 
 #include "incremental.h"
 
@@ -43,15 +44,51 @@ namespace gold
 using namespace gold;
 
 template<int size, bool big_endian>
+static typename Incremental_inputs_reader<size, big_endian>::
+    Incremental_input_entry_reader
+find_input_containing_global(
+    Incremental_inputs_reader<size, big_endian>& incremental_inputs,
+    unsigned int offset,
+    unsigned int* symndx)
+{
+  typedef Incremental_inputs_reader<size, big_endian> Inputs_reader;
+  for (unsigned int i = 0; i < incremental_inputs.input_file_count(); ++i)
+    {
+      typename Inputs_reader::Incremental_input_entry_reader input_file =
+	  incremental_inputs.input_file(i);
+      if (input_file.type() != INCREMENTAL_INPUT_OBJECT
+          && input_file.type() != INCREMENTAL_INPUT_ARCHIVE_MEMBER)
+        continue;
+      unsigned int nsyms = input_file.get_global_symbol_count();
+      if (offset >= input_file.get_symbol_offset(0)
+          && offset < input_file.get_symbol_offset(nsyms))
+	{
+	  *symndx = (offset - input_file.get_symbol_offset(0)) / 16;
+	  return input_file;
+	}
+    }
+  gold_unreachable();
+}
+
+template<int size, bool big_endian>
 static void
-dump_incremental_inputs(const char* argv0,
-                        const char* filename, Incremental_binary* inc)
+dump_incremental_inputs(const char* argv0, const char* filename,
+			Incremental_binary* inc)
 {
   bool t;
-  unsigned int strtab_shndx;
-  Incremental_binary::Location location;
-
-  t = inc->find_incremental_inputs_section(&location, &strtab_shndx);
+  unsigned int inputs_shndx;
+  unsigned int isymtab_shndx;
+  unsigned int irelocs_shndx;
+  unsigned int istrtab_shndx;
+  typedef Incremental_binary::Location Location;
+  typedef Incremental_binary::View View;
+  typedef Incremental_inputs_reader<size, big_endian> Inputs_reader;
+  typedef typename Inputs_reader::Incremental_input_entry_reader Entry_reader;
+
+  // Find the .gnu_incremental_inputs, _symtab, _relocs, and _strtab sections.
+
+  t = inc->find_incremental_inputs_sections(&inputs_shndx, &isymtab_shndx,
+					    &irelocs_shndx, &istrtab_shndx);
   if (!t)
     {
       fprintf(stderr, "%s: %s: no .gnu_incremental_inputs section\n", argv0,
@@ -59,105 +96,306 @@ dump_incremental_inputs(const char* argv0,
       exit (1);
     }
 
-  Incremental_binary::View inputs_view(inc->view(location));
-  const unsigned char* p = inputs_view.data();
+  elfcpp::Elf_file<size, big_endian, Incremental_binary> elf_file(inc);
+
+  // Get a view of the .gnu_incremental_inputs section.
+
+  Location inputs_location(elf_file.section_contents(inputs_shndx));
+  View inputs_view(inc->view(inputs_location));
+
+  // Get the .gnu_incremental_strtab section as a string table.
 
-  Incremental_inputs_header<size, big_endian> incremental_header(p);
+  Location istrtab_location(elf_file.section_contents(istrtab_shndx));
+  View istrtab_view(inc->view(istrtab_location));
+  elfcpp::Elf_strtab istrtab(istrtab_view.data(), istrtab_location.data_size);
 
-  const unsigned char* incremental_inputs_base =
-    (p + sizeof(Incremental_inputs_header_data));
+  // Create a reader object for the .gnu_incremental_inputs section.
 
-  if (incremental_header.get_version() != 1)
+  Incremental_inputs_reader<size, big_endian>
+      incremental_inputs(inputs_view.data(), istrtab);
+
+  if (incremental_inputs.version() != 1)
     {
       fprintf(stderr, "%s: %s: unknown incremental version %d\n", argv0,
-              filename, incremental_header.get_version());
+              filename, incremental_inputs.version());
       exit(1);
     }
 
-  elfcpp::Elf_file<size, big_endian, Incremental_binary> elf_file(inc);
-
-  if (elf_file.section_type(strtab_shndx) != elfcpp::SHT_STRTAB)
+  const char* command_line = incremental_inputs.command_line();
+  if (command_line == NULL)
     {
       fprintf(stderr,
-              "%s: %s: invalid string table section %u (type %d != %d)\n",
-              argv0, filename, strtab_shndx,
-              elf_file.section_type(strtab_shndx), elfcpp::SHT_STRTAB);
+              "%s: %s: failed to get link command line\n",
+              argv0, filename);
       exit(1);
     }
+  printf("Link command line: %s\n", command_line);
 
-  Incremental_binary::Location
-    strtab_location(elf_file.section_contents(strtab_shndx));
+  printf("\nInput files:\n");
+  for (unsigned int i = 0; i < incremental_inputs.input_file_count(); ++i)
+    {
+      typedef Incremental_inputs_reader<size, big_endian> Inputs_reader;
+      typename Inputs_reader::Incremental_input_entry_reader input_file =
+	  incremental_inputs.input_file(i);
+
+      const char* objname = input_file.filename();
+      if (objname == NULL)
+	{
+	  fprintf(stderr,"%s: %s: failed to get file name for object %u\n",
+		  argv0, filename, i);
+	  exit(1);
+	}
+      printf("[%d] %s\n", i, objname);
+
+      Timespec mtime = input_file.get_mtime();
+      printf("    Timestamp: %llu.%09d  %s",
+	     static_cast<unsigned long long>(mtime.seconds),
+	     mtime.nanoseconds,
+	     ctime(&mtime.seconds));
+
+      Incremental_input_type input_type = input_file.type();
+      printf("    Type: ");
+      switch (input_type)
+	{
+	case INCREMENTAL_INPUT_OBJECT:
+	  {
+	    printf("Object\n");
+	    printf("    Input section count: %d\n",
+		   input_file.get_input_section_count());
+	    printf("    Symbol count: %d\n",
+		   input_file.get_global_symbol_count());
+	  }
+	  break;
+	case INCREMENTAL_INPUT_ARCHIVE_MEMBER:
+	  {
+	    printf("Archive member\n");
+	    printf("    Input section count: %d\n",
+		   input_file.get_input_section_count());
+	    printf("    Symbol count: %d\n",
+		   input_file.get_global_symbol_count());
+	  }
+	  break;
+	case INCREMENTAL_INPUT_ARCHIVE:
+	  {
+	    printf("Archive\n");
+	    printf("    Member count: %d\n", input_file.get_member_count());
+	    printf("    Unused symbol count: %d\n",
+		   input_file.get_unused_symbol_count());
+	  }
+	  break;
+	case INCREMENTAL_INPUT_SHARED_LIBRARY:
+	  {
+	    printf("Shared library\n");
+	    printf("    Symbol count: %d\n",
+		   input_file.get_global_symbol_count());
+	  }
+	  break;
+	case INCREMENTAL_INPUT_SCRIPT:
+	  printf("Linker script\n");
+	  break;
+	default:
+	  fprintf(stderr, "%s: invalid file type for object %u: %d\n",
+		  argv0, i, input_type);
+	  exit(1);
+	}
+    }
 
-  Incremental_binary::View strtab_view(inc->view(strtab_location));
-  p = strtab_view.data();
+  printf("\nInput sections:\n");
+  for (unsigned int i = 0; i < incremental_inputs.input_file_count(); ++i)
+    {
+      typedef Incremental_inputs_reader<size, big_endian> Inputs_reader;
+      typedef typename Inputs_reader::Incremental_input_entry_reader
+          Entry_reader;
+
+      Entry_reader input_file(incremental_inputs.input_file(i));
+
+      if (input_file.type() != INCREMENTAL_INPUT_OBJECT
+	  && input_file.type() != INCREMENTAL_INPUT_ARCHIVE_MEMBER)
+	continue;
+
+      const char* objname = input_file.filename();
+      if (objname == NULL)
+	{
+	  fprintf(stderr,"%s: %s: failed to get file name for object %u\n",
+		  argv0, filename, i);
+	  exit(1);
+	}
+
+      printf("[%d] %s\n", i, objname);
+
+      printf("    %3s  %6s  %8s  %8s  %s\n",
+	     "n", "outndx", "offset", "size", "name");
+      unsigned int nsections = input_file.get_input_section_count();
+      for (unsigned int shndx = 0; shndx < nsections; ++shndx)
+	{
+	  typename Entry_reader::Input_section_info info(
+	      input_file.get_input_section(shndx));
+	  printf("    %3d  %6d  %8lld  %8lld  %s\n", shndx,
+		 info.output_shndx,
+		 static_cast<long long>(info.sh_offset),
+		 static_cast<long long>(info.sh_size),
+		 info.name);
+	}
+    }
 
-  elfcpp::Elf_strtab strtab(strtab_view.data(), strtab_location.data_size);
-  const char* command_line;
-  elfcpp::Elf_Word command_line_offset =
-    incremental_header.get_command_line_offset();
-  t = strtab.get_c_string(command_line_offset, &command_line);
+  printf("\nGlobal symbols per input file:\n");
+  for (unsigned int i = 0; i < incremental_inputs.input_file_count(); ++i)
+    {
+      typedef Incremental_inputs_reader<size, big_endian> Inputs_reader;
+      typedef typename Inputs_reader::Incremental_input_entry_reader
+          Entry_reader;
+
+      Entry_reader input_file(incremental_inputs.input_file(i));
+
+      if (input_file.type() != INCREMENTAL_INPUT_OBJECT
+	  && input_file.type() != INCREMENTAL_INPUT_ARCHIVE_MEMBER)
+	continue;
+
+      const char* objname = input_file.filename();
+      if (objname == NULL)
+	{
+	  fprintf(stderr,"%s: %s: failed to get file name for object %u\n",
+		  argv0, filename, i);
+	  exit(1);
+	}
+
+      printf("[%d] %s\n", i, objname);
+
+      unsigned int nsyms = input_file.get_global_symbol_count();
+      if (nsyms > 0)
+	printf("    %6s  %8s  %8s  %8s  %8s\n",
+	       "outndx", "offset", "chain", "#relocs", "rbase");
+      for (unsigned int symndx = 0; symndx < nsyms; ++symndx)
+	{
+	  typename Entry_reader::Global_symbol_info info(
+	      input_file.get_global_symbol_info(symndx));
+	  printf("    %6d  %8d  %8d  %8d  %8d\n",
+		 info.output_symndx,
+		 input_file.get_symbol_offset(symndx),
+		 info.next_offset,
+		 info.reloc_count,
+		 info.reloc_offset);
+	}
+    }
 
-  if (!t)
+  // Get a view of the .symtab section.
+
+  unsigned int symtab_shndx = elf_file.find_section_by_type(elfcpp::SHT_SYMTAB);
+  if (symtab_shndx == elfcpp::SHN_UNDEF)  // Not found.
     {
-      fprintf(stderr,
-              "%s: %s: failed to get link command line: %zu out of range\n",
-              argv0, filename,
-              static_cast<size_t>(command_line_offset));
-      exit(1);
+      fprintf(stderr, "%s: %s: no symbol table section\n", argv0, filename);
+      exit (1);
     }
+  Location symtab_location(elf_file.section_contents(symtab_shndx));
+  View symtab_view(inc->view(symtab_location));
 
-  printf("Link command line: %s\n", command_line);
+  // Get a view of the .strtab section.
 
-  printf("Input files:\n");
-  for (unsigned i = 0; i < incremental_header.get_input_file_count(); ++i)
+  unsigned int strtab_shndx = elf_file.section_link(symtab_shndx);
+  if (strtab_shndx == elfcpp::SHN_UNDEF
+      || strtab_shndx > elf_file.shnum()
+      || elf_file.section_type(strtab_shndx) != elfcpp::SHT_STRTAB)
     {
-      const unsigned char* input_p = incremental_inputs_base +
-        i * sizeof(Incremental_inputs_entry_data);
-      Incremental_inputs_entry<size, big_endian> input(input_p);
-      const char* objname;
+      fprintf(stderr, "%s: %s: no string table section\n", argv0, filename);
+      exit (1);
+    }
+  Location strtab_location(elf_file.section_contents(strtab_shndx));
+  View strtab_view(inc->view(strtab_location));
+  elfcpp::Elf_strtab strtab(strtab_view.data(), strtab_location.data_size);
+
+  // Get a view of the .gnu_incremental_symtab section.
 
-      t = strtab.get_c_string(input.get_filename_offset(), &objname);
-      if (!t)
+  Location isymtab_location(elf_file.section_contents(isymtab_shndx));
+  View isymtab_view(inc->view(isymtab_location));
+
+  // Get a view of the .gnu_incremental_relocs section.
+
+  Location irelocs_location(elf_file.section_contents(irelocs_shndx));
+  View irelocs_view(inc->view(irelocs_location));
+
+  // The .gnu_incremental_symtab section contains entries that parallel
+  // the global symbols of the main symbol table.  The sh_info field
+  // of the main symbol table's section header tells us how many global
+  // symbols there are, but that count does not include any global
+  // symbols that were forced local during the link.  Therefore, we
+  // use the size of the .gnu_incremental_symtab section to deduce
+  // the number of global symbols + forced-local symbols there are
+  // in the symbol table.
+  unsigned int sym_size = elfcpp::Elf_sizes<size>::sym_size;
+  unsigned int nsyms = symtab_location.data_size / sym_size;
+  unsigned int nglobals = isymtab_location.data_size / 4;
+  unsigned int first_global = nsyms - nglobals;
+  unsigned const char* sym_p = symtab_view.data() + first_global * sym_size;
+  unsigned const char* isym_p = isymtab_view.data();
+
+  Incremental_symtab_reader<big_endian> isymtab(isymtab_view.data());
+  Incremental_relocs_reader<size, big_endian> irelocs(irelocs_view.data());
+
+  printf("\nGlobal symbol table:\n");
+  for (unsigned int i = 0; i < nglobals; i++)
+    {
+      elfcpp::Sym<size, big_endian> sym(sym_p);
+      const char* symname;
+      if (!strtab.get_c_string(sym.get_st_name(), &symname))
+	symname = "<unknown>";
+      printf("[%d] %s\n", first_global + i, symname);
+      unsigned int offset = isymtab.get_list_head(i);
+      while (offset > 0)
         {
-          fprintf(stderr,"%s: %s: failed to get file name for object %u:"
-                  " %zu out of range\n", argv0, filename, i,
-                  static_cast<size_t>(input.get_filename_offset()));
-          exit(1);
-        }
-      printf("  %s\n", objname);
-      printf("    Timestamp sec = %llu\n",
-             static_cast<unsigned long long>(input.get_timestamp_sec()));
-      printf("    Timestamp nsec = %d\n", input.get_timestamp_nsec());
-      printf("    Type = ");
-      // TODO: print the data at input->data_offset once we have it.
-      elfcpp::Elf_Word input_type = input.get_input_type();
-      switch (input_type)
-      {
-      case INCREMENTAL_INPUT_OBJECT:
-        printf("Object\n");
-        break;
-      case INCREMENTAL_INPUT_ARCHIVE:
-        printf("Archive\n");
-        break;
-      case INCREMENTAL_INPUT_SHARED_LIBRARY:
-        printf("Shared library\n");
-        break;
-      case INCREMENTAL_INPUT_SCRIPT:
-        printf("Linker script\n");
-        if (input.get_data_offset() != 0)
-          {
-            fprintf(stderr,"%s: %s: %u is a script but offset is not zero",
-                    argv0, filename, i);
-            exit(1);
-          }
-        break;
-      case INCREMENTAL_INPUT_INVALID:
-      default:
-        fprintf(stderr, "%s: invalid file type for object %u: %d\n",
-                argv0, i, input_type);
-        exit(1);
-      }
+	  unsigned int sym_ndx;
+	  Entry_reader input_file =
+	      find_input_containing_global<size, big_endian>(incremental_inputs,
+							     offset, &sym_ndx);
+	  typename Entry_reader::Global_symbol_info sym_info(
+	      input_file.get_global_symbol_info(sym_ndx));
+	  printf("    %s (first reloc: %d, reloc count: %d)",
+		 input_file.filename(), sym_info.reloc_offset,
+		 sym_info.reloc_count);
+	  if (sym_info.output_symndx != first_global + i)
+	    printf(" ** wrong output symndx (%d) **", sym_info.output_symndx);
+	  printf("\n");
+	  // Dump the relocations from this input file for this symbol.
+	  unsigned int r_off = sym_info.reloc_offset;
+	  for (unsigned int j = 0; j < sym_info.reloc_count; j++)
+	    {
+	      printf("      %4d  relocation type %3d  shndx %d"
+		     "  offset %016llx  addend %016llx  %s\n",
+		     r_off,
+		     irelocs.get_r_type(r_off),
+		     irelocs.get_r_shndx(r_off),
+		     static_cast<long long>(irelocs.get_r_offset(r_off)),
+		     static_cast<long long>(irelocs.get_r_addend(r_off)),
+		     symname);
+	      r_off += irelocs.reloc_size;
+	    }
+	  offset = sym_info.next_offset;
+	}
+      sym_p += sym_size;
+      isym_p += 4;
     }
+
+  printf("\nUnused archive symbols:\n");
+  for (unsigned int i = 0; i < incremental_inputs.input_file_count(); ++i)
+    {
+      Entry_reader input_file(incremental_inputs.input_file(i));
+
+      if (input_file.type() != INCREMENTAL_INPUT_ARCHIVE)
+	continue;
+
+      const char* objname = input_file.filename();
+      if (objname == NULL)
+	{
+	  fprintf(stderr,"%s: %s: failed to get file name for object %u\n",
+		  argv0, filename, i);
+	  exit(1);
+	}
+
+      printf("[%d] %s\n", i, objname);
+      unsigned int nsyms = input_file.get_unused_symbol_count();
+      for (unsigned int symndx = 0; symndx < nsyms; ++symndx)
+        printf("    %s\n", input_file.get_unused_symbol(symndx));
+    }
+
 }
 
 int