Implement ar program.

Relax elflint in GNU ld mode for latest idiosyncracies.

16 files changed, 2160 insertions, 275 deletions

diff --git a/NEWS b/NEWS
index 095bebb3..b1e96856 100644
--- a/NEWS
+++ b/NEWS
@@ -1,3 +1,7 @@
+Version 0.126:
+
+new program: ar
+
 Version 0.125:
 
 elflint: Compare DT_GNU_HASH tests.
diff --git a/libelf/ChangeLog b/libelf/ChangeLog
index 8d1f289d..14001c7a 100644
--- a/libelf/ChangeLog
+++ b/libelf/ChangeLog
@@ -1,3 +1,9 @@
+2007-02-04  Ulrich Drepper  <drepper@redhat.com>
+
+	* Makefile (libelf.so): Build with -z relro.
+
+	* elf_begin.c (read_file): When using ELF_C_READ_MMAP use MAP_PRIVATE.
+
 2007-01-30  Ulrich Drepper  <drepper@redhat.com>
 
 	* nlist.c: Close file descriptor before returning.
diff --git a/libelf/Makefile.am b/libelf/Makefile.am
index f27d4f0b..b93f49c6 100644
--- a/libelf/Makefile.am
+++ b/libelf/Makefile.am
@@ -1,6 +1,6 @@
 ## Process this file with automake to create Makefile.in
 ##
-## Copyright (C) 1996-2001, 2002, 2003, 2004, 2005, 2006 Red Hat, Inc.
+## Copyright (C) 1996-2006, 2007 Red Hat, Inc.
 ## This file is part of Red Hat elfutils.
 ##
 ## Red Hat elfutils is free software; you can redistribute it and/or modify
@@ -107,7 +107,7 @@ libelf_so_SOURCES =
 libelf.so: libelf_pic.a libelf.map
 	$(LINK) -shared -o $@ -Wl,--whole-archive,$<,--no-whole-archive \
 		-Wl,--version-script,$(srcdir)/libelf.map,--no-undefined \
-		-Wl,--soname,$@.$(VERSION),-z,-defs
+		-Wl,--soname,$@.$(VERSION),-z,-defs,-z,relro
 	if readelf -d $@ | fgrep -q TEXTREL; then exit 1; fi
 	ln -fs $@ $@.$(VERSION)
 
diff --git a/libelf/elf_begin.c b/libelf/elf_begin.c
index be52f464..24bac42b 100644
--- a/libelf/elf_begin.c
+++ b/libelf/elf_begin.c
@@ -1,5 +1,5 @@
 /* Create descriptor for processing file.
-   Copyright (C) 1998-2005, 2006 Red Hat, Inc.
+   Copyright (C) 1998-2005, 2006, 2007 Red Hat, Inc.
    This file is part of Red Hat elfutils.
    Written by Ulrich Drepper <drepper@redhat.com>, 1998.
 
@@ -561,6 +561,7 @@ read_file (int fildes, off_t offset, size_t maxsize,
 					      ? PROT_READ
 					      : PROT_READ|PROT_WRITE),
 			      cmd == ELF_C_READ_MMAP_PRIVATE
+			      || cmd == ELF_C_READ_MMAP
 			      ? MAP_PRIVATE : MAP_SHARED,
 			      fildes, offset);
 
@@ -686,7 +687,7 @@ read_long_names (Elf *elf)
 	  /* NUL-terminate the string.  */
 	  *runp = '\0';
 
-	  /* Skip the NUL bzte and the \012.  */
+	  /* Skip the NUL byte and the \012.  */
 	  runp += 2;
 
 	  /* A sanity check.  Somebody might have generated invalid
diff --git a/src/ChangeLog b/src/ChangeLog
index 8c1b14e7..6e619e0d 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,18 @@
+2007-02-04  Ulrich Drepper  <drepper@redhat.com>
+
+	* ar.c: New file.
+	* arlib.c: New file.
+	* arlib2.c: New file.
+	* arlib.h: New file.
+	* Makefile (noinst_LIBRARIES): Add libar.
+	(libar_a_SOURCES): Define.
+	(ar_LDADD): Define.
+	(CFLAGS_ar): Define.
+	* ranlib.c: Change to use arlib.
+
+	* elflint.c (check_symtab): Work around GNU ld bug which omits
+	sections but not symbols in those sections.
+
 2007-01-10  Ulrich Drepper  <drepper@redhat.com>
 
 	* addr2line.c: Update copyright year.
diff --git a/src/Makefile.am b/src/Makefile.am
index 7c9eb842..230a8178 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,6 +1,6 @@
 ## Process this file with automake to create Makefile.in
 ##
-## Copyright (C) 1996-2002, 2003, 2004, 2005, 2006 Red Hat, Inc.
+## Copyright (C) 1996-2002, 2003, 2004, 2005, 2006, 2007 Red Hat, Inc.
 ## This file is part of Red Hat elfutils.
 ##
 ## Red Hat elfutils is free software; you can redistribute it and/or modify
@@ -34,7 +34,7 @@ endif
 AM_CFLAGS += -Wall -Wshadow -std=gnu99 $(native_ld_cflags) \
 	     $(if $($(*F)_no_Werror),,-Werror) \
 	     $(if $($(*F)_no_Wunused),,-Wunused -Wextra) \
-	     $(if $($(*F)_no_Wformat),,-Wformat=2)
+	     $(if $($(*F)_no_Wformat),,-Wformat=2) $(CFLAGS_$(*F))
 
 INCLUDES = -I$(srcdir) -I$(srcdir)/../libelf -I$(srcdir)/../libebl \
 	   -I$(srcdir)/../libdw -I$(srcdir)/../libdwfl \
@@ -52,15 +52,15 @@ native_ld = @native_ld@
 base_cpu = @base_cpu@
 
 bin_PROGRAMS = readelf nm size strip ld elflint findtextrel addr2line \
-	       elfcmp objdump ranlib strings
+	       elfcmp objdump ranlib strings ar
 
 
 ld_dsos = libld_elf_i386_pic.a
 if NATIVE_LD
-noinst_LIBRARIES = libld_elf.a
+noinst_LIBRARIES = libld_elf.a libar.a
 native_ld_cflags = -DBASE_ELF_NAME=elf_$(base_cpu)
 else
-noinst_LIBRARIES = libld_elf.a $(ld_dsos)
+noinst_LIBRARIES = libld_elf.a libar.a $(ld_dsos)
 noinst_PROGRAMS = $(ld_dsos:_pic.a=.so)
 endif
 if NEVER
@@ -76,10 +76,12 @@ textrel_check = if readelf -d $@ | fgrep -q TEXTREL; then exit 1; fi
 ld_SOURCES = ld.c ldgeneric.c ldlex.l ldscript.y symbolhash.c sectionhash.c \
 	     versionhash.c
 
+libar_a_SOURCES = arlib.c arlib2.c
+
 noinst_HEADERS = ld.h symbolhash.h sectionhash.h versionhash.h \
 		 ldscript.h xelf.h unaligned.h
 
-EXTRA_DIST = elf32-i386.script libld_elf_i386.map $(ld_modules)
+EXTRA_DIST = elf32-i386.script libld_elf_i386.map $(ld_modules) arlib.h
 ld_modules = i386_ld.c
 
 if MUDFLAP
@@ -117,8 +119,10 @@ findtextrel_LDADD = $(libdw) $(libelf) $(libmudflap)
 addr2line_LDADD = $(libdw) $(libmudflap)
 elfcmp_LDADD = $(libebl) $(libelf) $(libmudflap) -ldl
 objdump_LDADD  = $(libebl) $(libelf) $(libeu) $(libmudflap) -ldl
-ranlib_LDADD = $(libelf) $(libeu) $(libmudflap)
+ranlib_LDADD = libar.a $(libelf) $(libeu) $(libmudflap)
 strings_LDADD = $(libelf) $(libeu) $(libmudflap)
+ar_LDADD = libar.a $(libelf) $(libeu) $(libmudflap)
+CFLAGS_ar = -DAR=\"$(shell echo ar|sed '$(transform)')\"
 
 ldlex.o: ldscript.c
 ldlex_no_Werror = yes
diff --git a/src/ar.c b/src/ar.c
new file mode 100644
index 00000000..772c49c2
--- /dev/null
+++ b/src/ar.c
@@ -0,0 +1,1531 @@
+/* Create, modify, and extract from archives.
+   Copyright (C) 2005, 2007 Red Hat, Inc.
+   Written by Ulrich Drepper <drepper@redhat.com>, 2005.
+
+   Red Hat elfutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by the
+   Free Software Foundation; version 2 of the License.
+
+   Red Hat elfutils is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with Red Hat elfutils; if not, write to the Free Software Foundation,
+   Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+
+   Red Hat elfutils is an included package of the Open Invention Network.
+   An included package of the Open Invention Network is a package for which
+   Open Invention Network licensees cross-license their patents.  No patent
+   license is granted, either expressly or impliedly, by designation as an
+   included package.  Should you wish to participate in the Open Invention
+   Network licensing program, please visit www.openinventionnetwork.com
+   <http://www.openinventionnetwork.com>.  */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <argp.h>
+#include <assert.h>
+#include <error.h>
+#include <fcntl.h>
+#include <gelf.h>
+#include <libintl.h>
+#include <locale.h>
+#include <mcheck.h>
+#include <search.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdio_ext.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/statfs.h>
+#include <sys/time.h>
+
+#include <system.h>
+
+#include "arlib.h"
+
+
+/* Name and version of program.  */
+static void print_version (FILE *stream, struct argp_state *state);
+void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version;
+/* Prototypes for local functions.  */
+static int do_oper_extract (int oper, const char *arfname, char **argv,
+			    int argc, long int instance);
+static int do_oper_delete (const char *arfname, char **argv, int argc,
+			   long int instance);
+static int do_oper_insert (int oper, const char *arfname, char **argv,
+			   int argc, const char *member);
+
+
+/* Bug report address.  */
+const char *argp_program_bug_address = PACKAGE_BUGREPORT;
+
+
+/* Definitions of arguments for argp functions.  */
+static const struct argp_option options[] =
+{
+  { NULL, 0, NULL, 0, N_("Commands:"), 0 },
+  { NULL, 'd', NULL, 0, N_("Delete files from archive."), 0 },
+  { NULL, 'm', NULL, 0, N_("Move files in archive."), 0 },
+  { NULL, 'p', NULL, 0, N_("Print files in archive."), 0 },
+  { NULL, 'q', NULL, 0, N_("Quick append files to archive."), 0 },
+  { NULL, 'r', NULL, 0,
+    N_("Replace existing or insert new file into archive."), 0 },
+  { NULL, 't', NULL, 0, N_("Display content of archive."), 0 },
+  { NULL, 'x', NULL, 0, N_("Extract files from archive."), 0 },
+
+  { NULL, 0, NULL, 0, N_("Command Modifiers:"), 0 },
+  { NULL, 'o', NULL, 0, N_("Preserve original dates."), 0 },
+  { NULL, 'N', NULL, 0, N_("Use instance [COUNT] of name."), 0 },
+  { NULL, 'C', NULL, 0,
+    N_("Do not replace existing files with extracted files."), 0 },
+  { NULL, 'T', NULL, 0, N_("Allow filename to be truncated if necessary."),
+    0 },
+  { NULL, 'v', NULL, 0, N_("Provide verbose output."), 0 },
+  { NULL, 's', NULL, 0, N_("Force regeneration of symbol table."), 0 },
+  { NULL, 'a', NULL, 0, N_("Insert file after [MEMBER]."), 0 },
+  { NULL, 'b', NULL, 0, N_("Insert file before [MEMBER]."), 0 },
+  { NULL, 'i', NULL, 0, N_("Same as -b."), 0 },
+  { NULL, 'c', NULL, 0, N_("Suppress message when library has to be created."),
+    0 },
+  { NULL, 'P', NULL, 0, N_("Use full path for file matching."), 0 },
+  { NULL, 'u', NULL, 0, N_("Update only older files in archive."), 0 },
+
+  { NULL, 0, NULL, 0, NULL, 0 }
+};
+
+/* Short description of program.  */
+static const char doc[] = N_("Create, modify, and extract from archives.");
+
+/* Strings for arguments in help texts.  */
+static const char args_doc[] = N_("[MEMBER] [COUNT] ARCHIVE [FILE...]");
+
+/* Prototype for option handler.  */
+static error_t parse_opt (int key, char *arg, struct argp_state *state);
+
+/* Data structure to communicate with argp functions.  */
+static struct argp argp =
+{
+  options, parse_opt, args_doc, doc, NULL, NULL, NULL
+};
+
+
+/* What operation to perform.  */
+static enum
+  {
+    oper_none,
+    oper_delete,
+    oper_move,
+    oper_print,
+    oper_qappend,
+    oper_replace,
+    oper_list,
+    oper_extract
+  } operation;
+
+/* Modifiers.  */
+static bool verbose;
+static bool preserve_dates;
+static bool instance_specifed;
+static bool dont_replace_existing;
+static bool allow_truncate_fname;
+static bool force_symtab;
+static bool suppress_create_msg;
+static bool full_path;
+static bool update_newer;
+static enum { ipos_none, ipos_before, ipos_after } ipos;
+
+
+int
+main (int argc, char *argv[])
+{
+  /* Make memory leak detection possible.  */
+  mtrace ();
+
+  /* We use no threads here which can interfere with handling a stream.  */
+  (void) __fsetlocking (stdin, FSETLOCKING_BYCALLER);
+  (void) __fsetlocking (stdout, FSETLOCKING_BYCALLER);
+  (void) __fsetlocking (stderr, FSETLOCKING_BYCALLER);
+
+  /* Set locale.  */
+  (void) setlocale (LC_ALL, "");
+
+  /* Make sure the message catalog can be found.  */
+  (void) bindtextdomain (PACKAGE, LOCALEDIR);
+
+  /* Initialize the message catalog.  */
+  (void) textdomain (PACKAGE);
+
+  /* For historical reasons the options in the first parameter need
+     not be preceded by a dash.  Add it now if necessary.  */
+  if (argc > 1 && argv[1][0] != '-')
+    {
+      size_t len = strlen (argv[1]) + 1;
+      char *newp = alloca (len + 1);
+      newp[0] = '-';
+      memcpy (&newp[1], argv[1], len);
+      argv[1] = newp;
+    }
+
+  /* Parse and process arguments.  */
+  int remaining;
+  (void) argp_parse (&argp, argc, argv, ARGP_IN_ORDER, &remaining, NULL);
+
+  /* Tell the library which version we are expecting.  */
+  (void) elf_version (EV_CURRENT);
+
+  /* Handle the [MEMBER] parameter.  */
+  const char *member = NULL;
+  if (ipos != ipos_none)
+    {
+      /* Only valid for certain operations.  */
+      if (operation == oper_extract && operation == oper_delete)
+	error (1, 0, gettext ("\
+'a', 'b', and 'i' are only allowed with the 'm' and 'r' options"));
+
+      if (remaining == argc)
+	{
+	  error (0, 0, gettext ("MEMBER parameter required"));
+	  argp_help (&argp, stderr, ARGP_HELP_SEE, AR);
+	  exit (EXIT_FAILURE);
+	}
+
+      member = argv[remaining++];
+    }
+
+  /* Handle the [COUNT] parameter.  */
+  long int instance = -1;
+  if (instance_specifed)
+    {
+      /* Only valid for certain operations.  */
+      if (operation == oper_extract && operation == oper_delete)
+	error (1, 0, gettext ("\
+'N' is only meaningful with the 'x' and 'd' options"));
+
+      if (remaining == argc)
+	{
+	  error (0, 0, gettext ("COUNT parameter required"));
+	  argp_help (&argp, stderr, ARGP_HELP_SEE, AR);
+	  exit (EXIT_FAILURE);
+	}
+
+      char *endp;
+      errno = 0;
+      if (((instance = strtol (argv[remaining], &endp, 10)) == LONG_MAX
+	   && errno == ERANGE)
+	  || instance <= 0
+	  || *endp != '\0')
+	error (1, 0, gettext ("invalid COUNT parameter %s"), argv[remaining]);
+
+      ++remaining;
+    }
+
+  if ((dont_replace_existing || allow_truncate_fname)
+      && unlikely (operation != oper_extract))
+    error (1, 0, gettext ("'%' is only meaningful with the 'x' option"),
+	   dont_replace_existing ? 'C' : 'T');
+
+  /* There must at least be one more parameter specifying the archive.   */
+  if (remaining == argc)
+    {
+      error (0, 0, gettext ("Archive name required"));
+      argp_help (&argp, stderr, ARGP_HELP_SEE, AR);
+      exit (EXIT_FAILURE);
+    }
+
+  const char *arfname = argv[remaining++];
+  argv += remaining;
+  argc -= remaining;
+
+  int status;
+  switch (operation)
+    {
+    case oper_list:
+    case oper_print:
+      status = do_oper_extract (operation, arfname, argv, argc, -1);
+      break;
+
+    case oper_extract:
+      status = do_oper_extract (operation, arfname, argv, argc, instance);
+      break;
+
+    case oper_delete:
+      status = do_oper_delete (arfname, argv, argc, instance);
+      break;
+
+    case oper_move:
+    case oper_qappend:
+    case oper_replace:
+      status = do_oper_insert (operation, arfname, argv, argc, member);
+      break;
+
+    default:
+      assert (! "should not happen");
+      status = 1;
+      break;
+    }
+
+  return status;
+}
+
+
+/* Print the version information.  */
+static void
+print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
+{
+  fprintf (stream, "ar (%s) %s\n", PACKAGE_NAME, VERSION);
+  fprintf (stream, gettext ("\
+Copyright (C) %s Red Hat, Inc.\n\
+This is free software; see the source for copying conditions.  There is NO\n\
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
+"), "2007");
+  fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
+}
+
+
+/* Handle program arguments.  */
+static error_t
+parse_opt (int key, char *arg __attribute__ ((unused)),
+	   struct argp_state *state __attribute__ ((unused)))
+{
+  switch (key)
+    {
+    case 'd':
+    case 'm':
+    case 'p':
+    case 'q':
+    case 'r':
+    case 't':
+    case 'x':
+      if (operation != oper_none)
+	{
+	  error (0, 0, gettext ("More than one operation specified"));
+	  argp_help (&argp, stderr, ARGP_HELP_SEE, AR);
+	  exit (EXIT_FAILURE);
+	}
+
+      switch (key)
+	{
+	case 'd':
+	  operation = oper_delete;
+	  break;
+	case 'm':
+	  operation = oper_move;
+	  break;
+	case 'p':
+	  operation = oper_print;
+	  break;
+	case 'q':
+	  operation = oper_qappend;
+	  break;
+	case 'r':
+	  operation = oper_replace;
+	  break;
+	case 't':
+	  operation = oper_list;
+	  break;
+	case 'x':
+	  operation = oper_extract;
+	  break;
+	}
+      break;
+
+    case 'a':
+      ipos = ipos_after;
+      break;
+
+    case 'b':
+    case 'i':
+      ipos = ipos_before;
+      break;
+
+    case 'c':
+      suppress_create_msg = true;
+      break;
+
+    case 'C':
+      dont_replace_existing = true;
+      break;
+
+    case 'N':
+      instance_specifed = true;
+      break;
+
+    case 'o':
+      preserve_dates = true;
+      break;
+
+    case 'P':
+      full_path = true;
+      break;
+
+    case 's':
+      force_symtab = true;
+      break;
+
+    case 'T':
+      allow_truncate_fname = true;
+      break;
+
+    case 'v':
+      verbose = true;
+      break;
+
+    default:
+      return ARGP_ERR_UNKNOWN;
+    }
+  return 0;
+}
+
+
+static int
+open_archive (const char *arfname, int flags, int mode, Elf **elf,
+	      struct stat *st, bool miss_allowed)
+{
+  int fd = open (arfname, flags, mode);
+  if (fd == -1)
+    {
+      if (miss_allowed)
+	return -1;
+
+      error (EXIT_FAILURE, errno, gettext ("cannot open archive '%s'"),
+	     arfname);
+    }
+
+  if (elf != NULL)
+    {
+      Elf_Cmd cmd = flags == O_RDONLY ? ELF_C_READ_MMAP : ELF_C_RDWR_MMAP;
+
+      *elf = elf_begin (fd, cmd, NULL);
+      if (*elf == NULL)
+	error (EXIT_FAILURE, 0, gettext ("cannot open archive '%s': %s"),
+	       arfname, elf_errmsg (-1));
+
+      if (flags == O_RDONLY && elf_kind (*elf) != ELF_K_AR)
+	error (EXIT_FAILURE, 0, gettext ("%s: not an archive file"), arfname);
+    }
+
+  if (st != NULL && fstat (fd, st) != 0)
+    error (EXIT_FAILURE, errno, gettext ("cannot stat archive '%s'"),
+	   arfname);
+
+  return fd;
+}
+
+
+static void
+not_found (int argc, char *argv[argc], bool found[argc])
+{
+  for (int i = 0; i < argc; ++i)
+    if (!found[i])
+      printf (gettext ("no entry %s in archive\n"), argv[i]);
+}
+
+
+static int
+copy_content (Elf *elf, int newfd, off_t off, size_t n)
+{
+  size_t len;
+  char *rawfile = elf_rawfile (elf, &len);
+
+  assert (off + n <= len);
+
+  /* Tell the kernel we will read all the pages sequentially.  */
+  size_t ps = sysconf (_SC_PAGESIZE);
+  if (n > 2 * ps)
+    posix_madvise (rawfile + (off & ~(ps - 1)), n, POSIX_MADV_SEQUENTIAL);
+
+  return write_retry (newfd, rawfile + off, n) != (ssize_t) n;
+}
+
+
+static int
+do_oper_extract (int oper, const char *arfname, char **argv, int argc,
+		 long int instance)
+{
+  bool found[argc];
+  memset (found, '\0', sizeof (found));
+
+  struct statfs f;
+  f.f_namelen = 0;
+
+  off_t index_off = -1;
+  size_t index_size = 0;
+  off_t cur_off = SARMAG;
+
+  int status = 0;
+  Elf *elf;
+  int fd = open_archive (arfname, O_RDONLY, 0, &elf, NULL, false);
+
+  if (hcreate (2 * argc) == 0)
+    error (EXIT_FAILURE, errno, gettext ("cannot create hash table"));
+
+  for (int cnt = 0; cnt < argc; ++cnt)
+    {
+      ENTRY entry = { .key = argv[cnt], .data = &argv[cnt] };
+      if (hsearch (entry, ENTER) == NULL)
+	error (EXIT_FAILURE, errno,
+	       gettext ("cannot insert into hash table"));
+    }
+
+  struct arlib_symtab symtab;
+  struct stat st;
+  if (force_symtab)
+    {
+      if (fstat (fd, &st) != 0)
+	{
+	  error (0, errno, gettext ("cannot stat '%s'"), arfname);
+	  close (fd);
+	  return 1;
+	}
+      arlib_init (&symtab);
+    }
+
+  Elf_Cmd cmd = ELF_C_READ_MMAP;
+  Elf *subelf;
+  while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
+    {
+      Elf_Arhdr *arhdr = elf_getarhdr (subelf);
+
+      if (strcmp (arhdr->ar_name, "/") == 0)
+	{
+	  index_off = elf_getaroff (subelf);
+	  index_size = arhdr->ar_size;
+	  goto next;
+	}
+      if (strcmp (arhdr->ar_name, "//") == 0)
+	goto next;
+
+      if (force_symtab)
+	{
+	  arlib_add_symbols (elf, arfname, arhdr->ar_name, &symtab, cur_off);
+	  cur_off += (((arhdr->ar_size + 1) & ~((off_t) 1))
+		      + sizeof (struct ar_hdr));
+	}
+
+      bool do_extract = argc <= 0;
+      if (!do_extract)
+	{
+	  ENTRY entry;
+	  entry.key = arhdr->ar_name;
+	  ENTRY *res = hsearch (entry, FIND);
+	  if (res != NULL && (instance < 0 || instance-- == 0)
+	      && !found[(char **) res->data - argv])
+	    found[(char **) res->data - argv] = do_extract = true;
+	}
+
+      if (do_extract)
+	{
+	  if (verbose)
+	    {
+	      if (oper == oper_print)
+		{
+		  printf ("\n<%s>\n\n", arhdr->ar_name);
+
+		  /* We have to flush now because now we use the descriptor
+		     directly.  */
+		  fflush (stdout);
+		}
+	      else if (oper == oper_list)
+		{
+		  char datestr[100];
+		  strftime (datestr, sizeof (datestr), "%b %e %H:%M %Y",
+			    localtime (&arhdr->ar_date));
+
+		  printf ("%c%c%c%c%c%c%c%c%c %u/%u %6ju %s %s\n",
+			  (arhdr->ar_mode & S_IRUSR) ? 'r' : '-',
+			  (arhdr->ar_mode & S_IWUSR) ? 'w' : '-',
+			  (arhdr->ar_mode & S_IXUSR)
+			  ? ((arhdr->ar_mode & S_ISUID) ? 's' : 'x')
+			  : ((arhdr->ar_mode & S_ISUID) ? 'S' : '-'),
+			  (arhdr->ar_mode & S_IRGRP) ? 'r' : '-',
+			  (arhdr->ar_mode & S_IWGRP) ? 'w' : '-',
+			  (arhdr->ar_mode & S_IXGRP)
+			  ? ((arhdr->ar_mode & S_ISGID) ? 's' : 'x')
+			  : ((arhdr->ar_mode & S_ISGID) ? 'S' : '-'),
+			  (arhdr->ar_mode & S_IROTH) ? 'r' : '-',
+			  (arhdr->ar_mode & S_IWOTH) ? 'w' : '-',
+			  (arhdr->ar_mode & S_IXOTH)
+			  ? ((arhdr->ar_mode & S_ISVTX) ? 't' : 'x')
+			  : ((arhdr->ar_mode & S_ISVTX) ? 'T' : '-'),
+			  arhdr->ar_uid,
+			  arhdr->ar_gid,
+			  (uintmax_t) arhdr->ar_size,
+			  datestr,
+			  arhdr->ar_name);
+		}
+	      else
+		printf ("x - %s\n", arhdr->ar_name);
+	    }
+
+	  if (oper == oper_list)
+	    {
+	      if (!verbose)
+		puts (arhdr->ar_name);
+
+	      goto next;
+	    }
+
+	  size_t nleft;
+	  char *data = elf_rawfile (subelf, &nleft);
+	  if (data == NULL)
+	    {
+	      error (0, 0, gettext ("cannot read content of %s: %s"),
+		     arhdr->ar_name, elf_errmsg (-1));
+	      status = 1;
+	      goto next;
+	    }
+
+	  int xfd;
+	  char tempfname[] = "XXXXXX";
+	  bool use_mkstemp = true;
+
+	  if (oper == oper_print)
+	    xfd = STDOUT_FILENO;
+	  else
+	    {
+	      xfd = mkstemp (tempfname);
+	      if (unlikely (xfd == -1))
+		{
+		  /* We cannot create a temporary file.  Try to overwrite
+		     the file or create it if it does not exist.  */
+		  int flags = O_WRONLY | O_CREAT;
+		  if (dont_replace_existing)
+		    flags |= O_EXCL;
+		  else
+		    flags |= O_TRUNC;
+		  xfd = open (arhdr->ar_name, flags, 0600);
+		  if (unlikely (xfd == -1))
+		    {
+		      int printlen = INT_MAX;
+
+		      if (errno == ENAMETOOLONG && allow_truncate_fname
+			  && (f.f_namelen != 0 || statfs (".", &f) == 0))
+			{
+			  /* Try to truncate the name.  First find out by how
+			     much.  */
+			  printlen = f.f_namelen;
+			  char truncfname[f.f_namelen + 1];
+			  *((char *) mempcpy (truncfname, arhdr->ar_name,
+					      f.f_namelen)) = '\0';
+
+			  xfd = open (truncfname, flags, 0600);
+			}
+
+		      if (xfd == -1)
+			{
+			  error (0, errno, gettext ("cannot open %.*s"),
+				 (int) printlen, arhdr->ar_name);
+			  status = 1;
+			  goto next;
+			}
+		    }
+
+		  use_mkstemp = false;
+		}
+	    }
+
+	  ssize_t n;
+	  while ((n = TEMP_FAILURE_RETRY (write (xfd, data, nleft))) != -1)
+	    {
+	      nleft -= n;
+	      if (nleft == 0)
+		break;
+	      data += n;
+	    }
+
+	  if (unlikely (n == -1))
+	    {
+	      error (0, errno, gettext ("failed to write %s"), arhdr->ar_name);
+	      status = 1;
+	      unlink (tempfname);
+	      close (xfd);
+	      goto next;
+	    }
+
+	  if (oper != oper_print)
+	    {
+	      /* Fix up the mode.  */
+	      if (unlikely (fchmod (xfd, arhdr->ar_mode) != 0))
+		{
+		  error (0, errno, gettext ("cannot change mode of %s"),
+			 arhdr->ar_name);
+		  status = 0;
+		}
+
+	      if (preserve_dates)
+		{
+		  struct timeval tv[2];
+		  tv[0].tv_sec = arhdr->ar_date;
+		  tv[0].tv_usec = 0;
+		  tv[1].tv_sec = arhdr->ar_date;
+		  tv[1].tv_usec = 0;
+
+		  if (unlikely (futimes (xfd, tv) != 0))
+		    {
+		      error (0, errno,
+			     gettext ("cannot change modification time of %s"),
+			     arhdr->ar_name);
+		      status = 1;
+		    }
+		}
+
+	      /* If we used a temporary file, move it do the right
+		 name now.  */
+	      if (use_mkstemp)
+		{
+		  int r;
+
+		  if (dont_replace_existing)
+		    {
+		      r = link (tempfname, arhdr->ar_name);
+		      if (likely (r == 0))
+			unlink (tempfname);
+		    }
+		  else
+		    r = rename (tempfname, arhdr->ar_name);
+
+		  if (unlikely (r) != 0)
+		    {
+		      int printlen = INT_MAX;
+
+		      if (errno == ENAMETOOLONG && allow_truncate_fname
+			  && (f.f_namelen != 0 || statfs (".", &f) == 0))
+			{
+			  /* Try to truncate the name.  First find out by how
+			     much.  */
+			  printlen = f.f_namelen;
+			  char truncfname[f.f_namelen + 1];
+			  *((char *) mempcpy (truncfname, arhdr->ar_name,
+					      f.f_namelen)) = '\0';
+
+			  if (dont_replace_existing)
+			    {
+			      r = link (tempfname, truncfname);
+			      if (likely (r == 0))
+				unlink (tempfname);
+			    }
+			  else
+			    r = rename (tempfname, truncfname);
+			}
+
+		      if (r != 0)
+			{
+			  error (0, errno, gettext ("\
+cannot rename temporary file to %.*s"),
+				 printlen, arhdr->ar_name);
+			  unlink (tempfname);
+			  status = 1;
+			}
+		    }
+		}
+
+	      close (xfd);
+	    }
+	}
+
+    next:
+      cmd = elf_next (subelf);
+      if (elf_end (subelf) != 0)
+	error (1, 0, "%s: %s", arfname, elf_errmsg (-1));
+    }
+
+  hdestroy ();
+
+  if (force_symtab)
+    {
+      arlib_finalize (&symtab);
+
+      if (symtab.symsnamelen != 0
+	  /* We have to rewrite the file also if it initially had an index
+	     but now does not need one anymore.  */
+	  || (symtab.symsnamelen == 0 && index_size != 0))
+	{
+	  char tmpfname[strlen (arfname) + 7];
+	  strcpy (stpcpy (tmpfname, arfname), "XXXXXX");
+	  int newfd = mkstemp (tmpfname);
+	  if (unlikely (newfd == -1))
+	    {
+	    nonew:
+	      error (0, errno, gettext ("cannot create new file"));
+	      status = 1;
+	    }
+	  else
+	    {
+	      /* Create the header.  */
+	      if (unlikely (write_retry (newfd, ARMAG, SARMAG) != SARMAG))
+		{
+		  // XXX Use /prof/self/fd/%d ???
+		nonew_unlink:
+		  unlink (tmpfname);
+		  if (newfd != -1)
+		    close (newfd);
+		  goto nonew;
+		}
+
+	      /* Create the new file.  There are three parts as far we are
+		 concerned: 1. original context before the index, 2. the
+		 new index, 3. everything after the new index.  */
+	      off_t rest_off;
+	      if (index_off != -1)
+		rest_off = (index_off + sizeof (struct ar_hdr)
+			    + ((index_size + 1) & ~1ul));
+	      else
+		rest_off = SARMAG;
+
+	      if ((symtab.symsnamelen != 0
+		   && ((write_retry (newfd, symtab.symsoff,
+				     symtab.symsofflen)
+			!= (ssize_t) symtab.symsofflen)
+		       || (write_retry (newfd, symtab.symsname,
+					symtab.symsnamelen)
+			   != (ssize_t) symtab.symsnamelen)))
+		  /* Even if the original file had content before the
+		     symbol table, we write it in the correct order.  */
+		  || (index_off != SARMAG
+		      && copy_content (elf, newfd, SARMAG, index_off - SARMAG))
+		  || copy_content (elf, newfd, rest_off, st.st_size - rest_off)
+		  /* Set the mode of the new file to the same values the
+		     original file has.  */
+		  || fchmod (newfd, st.st_mode & ALLPERMS) != 0
+		  /* Never complain about fchown failing.  */
+		  || (fchown (newfd, st.st_uid, st.st_gid),
+		      close (newfd) != 0)
+		  || (newfd = -1, rename (tmpfname, arfname) != 0))
+		goto nonew_unlink;
+	    }
+	}
+    }
+
+  elf_end (elf);
+
+  close (fd);
+
+  not_found (argc, argv, found);
+
+  return status;
+}
+
+
+struct armem
+{
+  off_t off;
+  off_t old_off;
+  size_t size;
+  long int long_name_off;
+  struct armem *next;
+  void *mem;
+  time_t sec;
+  uid_t uid;
+  gid_t gid;
+  mode_t mode;
+  const char *name;
+  Elf *elf;
+};
+
+
+static int
+write_member (struct armem *memb, off_t *startp, off_t *lenp, Elf *elf,
+	      off_t end_off, int newfd)
+{
+  struct ar_hdr arhdr;
+  char tmpbuf[sizeof (arhdr.ar_name) + 1];
+
+  bool changed_header = memb->long_name_off != -1;
+  if (changed_header)
+    {
+      /* In case of a long file name we assume the archive header
+	 changed and we write it here.  */
+      memcpy (&arhdr, elf_rawfile (elf, NULL) + *startp, sizeof (arhdr));
+
+      snprintf (tmpbuf, sizeof (tmpbuf), "/%-*ld",
+		(int) sizeof (arhdr.ar_name), memb->long_name_off);
+      changed_header = memcmp (arhdr.ar_name, tmpbuf,
+			       sizeof (arhdr.ar_name)) != 0;
+    }
+
+  /* If the files are adjacent in the old file extend the range.  */
+  if (*startp != -1 && !changed_header && *startp + *lenp == memb->old_off)
+    {
+      /* Extend the current range.  */
+      *lenp += (memb->next != NULL
+		? memb->next->off : end_off) - memb->off;
+      return 0;
+    }
+
+  /* Write out the old range.  */
+  if (*startp != -1 && copy_content (elf, newfd, *startp, *lenp))
+    return -1;
+
+  *startp = memb->old_off;
+  *lenp = (memb->next != NULL ? memb->next->off : end_off) - memb->off;
+
+  if (changed_header)
+    {
+      memcpy (arhdr.ar_name, tmpbuf, sizeof (arhdr.ar_name));
+
+      if (unlikely (write_retry (newfd, &arhdr, sizeof (arhdr))
+		    != sizeof (arhdr)))
+	return -1;
+
+      *startp += sizeof (struct ar_hdr);
+      assert ((size_t) *lenp >= sizeof (struct ar_hdr));
+      *lenp -= sizeof (struct ar_hdr);
+    }
+
+  return 0;
+}
+
+
+static int
+do_oper_delete (const char *arfname, char **argv, int argc,
+		long int instance)
+{
+  bool *found = alloca (sizeof (bool) * argc);
+  memset (found, '\0', sizeof (found));
+
+  /* List of the files we keep.  */
+  struct armem *to_copy = NULL;
+
+  int status = 0;
+  Elf *elf;
+  struct stat st;
+  int fd = open_archive (arfname, O_RDONLY, 0, &elf, &st, false);
+
+  if (hcreate (2 * argc) == 0)
+    error (EXIT_FAILURE, errno, gettext ("cannot create hash table"));
+
+  for (int cnt = 0; cnt < argc; ++cnt)
+    {
+      ENTRY entry = { .key = argv[cnt], .data = &argv[cnt] };
+      if (hsearch (entry, ENTER) == NULL)
+	error (EXIT_FAILURE, errno,
+	       gettext ("cannot insert into hash table"));
+    }
+
+  struct arlib_symtab symtab;
+  arlib_init (&symtab);
+
+  off_t cur_off = SARMAG;
+  Elf_Cmd cmd = ELF_C_READ_MMAP;
+  Elf *subelf;
+  while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
+    {
+      Elf_Arhdr *arhdr = elf_getarhdr (subelf);
+
+      /* Ignore the symbol table and the long file name table here.  */
+      if (strcmp (arhdr->ar_name, "/") == 0
+	  || strcmp (arhdr->ar_name, "//") == 0)
+	goto next;
+
+      bool do_delete = argc <= 0;
+      if (!do_delete)
+	{
+	  ENTRY entry;
+	  entry.key = arhdr->ar_name;
+	  ENTRY *res = hsearch (entry, FIND);
+	  if (res != NULL && (instance < 0 || instance-- == 0)
+	      && !found[(char **) res->data - argv])
+	    found[(char **) res->data - argv] = do_delete = true;
+	}
+
+      if (do_delete)
+	{
+	  if (verbose)
+	    printf ("d - %s\n", arhdr->ar_name);
+	}
+      else
+	{
+	  struct armem *newp = alloca (sizeof (struct armem));
+	  newp->old_off = elf_getaroff (subelf);
+	  newp->off = cur_off;
+
+	  cur_off += (((arhdr->ar_size + 1) & ~((off_t) 1))
+		      + sizeof (struct ar_hdr));
+
+	  if (to_copy == NULL)
+	    to_copy = newp->next = newp;
+	  else
+	    {
+	      newp->next = to_copy->next;
+	      to_copy = to_copy->next = newp;
+	    }
+
+	  /* If we recreate the symbol table read the file's symbol
+	     table now.  */
+	  arlib_add_symbols (subelf, arfname, arhdr->ar_name, &symtab,
+			     newp->off);
+
+	  /* Remember long file names.  */
+	  size_t ar_namelen = strlen (arhdr->ar_name);
+	  if (ar_namelen > MAX_AR_NAME_LEN)
+	    newp->long_name_off = arlib_add_long_name (&symtab,
+						       arhdr->ar_name,
+						       ar_namelen);
+	  else
+	    newp->long_name_off = -1l;
+	}
+
+    next:
+      cmd = elf_next (subelf);
+      if (elf_end (subelf) != 0)
+	error (1, 0, "%s: %s", arfname, elf_errmsg (-1));
+    }
+
+  arlib_finalize (&symtab);
+
+  hdestroy ();
+
+  /* Create a new, temporary file in the same directory as the
+     original file.  */
+  char tmpfname[strlen (arfname) + 7];
+  strcpy (stpcpy (tmpfname, arfname), "XXXXXX");
+  int newfd = mkstemp (tmpfname);
+  if (unlikely (newfd == -1))
+    goto nonew;
+
+  /* Create the header.  */
+  if (unlikely (write_retry (newfd, ARMAG, SARMAG) != SARMAG))
+    {
+      // XXX Use /prof/self/fd/%d ???
+    nonew_unlink:
+      unlink (tmpfname);
+      if (newfd != -1)
+	close (newfd);
+    nonew:
+      error (0, errno, gettext ("cannot create new file"));
+      status = 1;
+      goto errout;
+    }
+
+  /* If the archive is empty that is all we have to do.  */
+  if (likely (to_copy != NULL))
+    {
+      /* Write the symbol table or the long file name table or both.  */
+      if (symtab.symsnamelen != 0
+	  && ((write_retry (newfd, symtab.symsoff, symtab.symsofflen)
+	       != (ssize_t) symtab.symsofflen)
+	      || (write_retry (newfd, symtab.symsname, symtab.symsnamelen)
+		  != (ssize_t) symtab.symsnamelen)))
+	goto nonew_unlink;
+
+      if (symtab.longnameslen > sizeof (struct ar_hdr)
+	  && (write_retry (newfd, symtab.longnames, symtab.longnameslen)
+	      != (ssize_t) symtab.longnameslen))
+	goto nonew_unlink;
+
+      /* NULL-terminate the list of files to copy.  */
+      struct armem *last = to_copy;
+      to_copy = to_copy->next;
+      last->next = NULL;
+
+      off_t start = -1;
+      off_t len = -1;
+
+      do
+	if (write_member (to_copy, &start, &len, elf, cur_off, newfd) != 0)
+	  goto nonew_unlink;
+      while ((to_copy = to_copy->next) != NULL);
+
+      /* Write the last part.  */
+      if (copy_content (elf, newfd, start, len))
+	goto nonew_unlink;
+    }
+
+  /* Set the mode of the new file to the same values the original file
+     has.  */
+  if (fchmod (newfd, st.st_mode & ALLPERMS) != 0
+      /* Never complain about fchown failing.  */
+      || (fchown (newfd, st.st_uid, st.st_gid),
+	  close (newfd) != 0)
+      || (newfd = -1, rename (tmpfname, arfname) != 0))
+    goto nonew_unlink;
+
+ errout:
+#ifdef DEBUG
+  elf_end (elf);
+
+  arlib_fini (&symtab);
+
+  close (fd);
+#endif
+
+  not_found (argc, argv, found);
+
+  return status;
+}
+
+
+static void
+no0print (bool ofmt, char *buf, int bufsize, long int val)
+{
+  char tmpbuf[bufsize + 1];
+  snprintf (tmpbuf, sizeof (tmpbuf), ofmt ? "%-*lo" : "%-*ld", bufsize, val);
+  memcpy (buf, tmpbuf, bufsize);
+}
+
+
+static int
+do_oper_insert (int oper, const char *arfname, char **argv, int argc,
+		const char *member)
+{
+  int status = 0;
+  Elf *elf;
+  struct stat st;
+  int fd = open_archive (arfname, O_RDONLY, 0, &elf, &st, oper != oper_move);
+
+  /* List of the files we keep.  */
+  struct armem *all = NULL;
+  struct armem *after_memberelem = NULL;
+  struct armem **found = alloca (sizeof (*found) * argc);
+  memset (found, '\0', sizeof (*found) * argc);
+
+  struct arlib_symtab symtab;
+  arlib_init (&symtab);
+
+  if (fd == -1)
+    {
+      if (!suppress_create_msg)
+	fprintf (stderr, "%s: creating %s\n", AR, arfname);
+
+      goto no_old;
+    }
+
+  /* Store the names of all files from the command line in a hash
+     table so that we can match it.  Note that when no file name is
+     given we are basically doing nothing except recreating the
+     index.  */
+  if (oper != oper_qappend)
+    {
+      if (hcreate (2 * argc) == 0)
+	error (EXIT_FAILURE, errno, gettext ("cannot create hash table"));
+
+      for (int cnt = 0; cnt < argc; ++cnt)
+	{
+	  ENTRY entry;
+	  entry.key = full_path ? argv[cnt] : basename (argv[cnt]);
+	  entry.data = &argv[cnt];
+	  if (hsearch (entry, ENTER) == NULL)
+	    error (EXIT_FAILURE, errno,
+		   gettext ("cannot insert into hash table"));
+	}
+    }
+
+  /* While iterating over the current content of the archive we must
+     determine a number of things: which archive members to keep,
+     which are replaced, and where to insert the new members.  */
+  off_t cur_off = SARMAG;
+  Elf_Cmd cmd = ELF_C_READ_MMAP;
+  Elf *subelf;
+  while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
+    {
+      Elf_Arhdr *arhdr = elf_getarhdr (subelf);
+
+      /* Ignore the symbol table and the long file name table here.  */
+      if (strcmp (arhdr->ar_name, "/") == 0
+	  || strcmp (arhdr->ar_name, "//") == 0)
+	goto next;
+
+      struct armem *newp = alloca (sizeof (struct armem));
+      newp->old_off = elf_getaroff (subelf);
+      newp->size = arhdr->ar_size;
+      newp->sec = arhdr->ar_date;
+      newp->mem = NULL;
+
+      /* Remember long file names.  */
+      size_t ar_namelen = strlen (arhdr->ar_name);
+      if (ar_namelen > MAX_AR_NAME_LEN)
+	newp->long_name_off = arlib_add_long_name (&symtab, arhdr->ar_name,
+						   ar_namelen);
+      else
+	newp->long_name_off = -1l;
+
+      /* Check whether this is a file we are looking for.  */
+      if (oper != oper_qappend)
+	{
+	  /* Check whether this is the member used as the insert point.  */
+	  if (member != NULL && strcmp (arhdr->ar_name, member) == 0)
+	    {
+	      /* Note that all == NULL means insert at the beginning.  */
+	      if (ipos == ipos_before)
+		after_memberelem = all;
+	      else
+		after_memberelem = newp;
+	      member = NULL;
+	    }
+
+	  ENTRY entry;
+	  entry.key = arhdr->ar_name;
+	  ENTRY *res = hsearch (entry, FIND);
+	  if (res != NULL && found[(char **) res->data - argv] == NULL)
+	    {
+	      found[(char **) res->data - argv] = newp;
+
+	      /* If we insert before or after a certain element move
+		 all files to a special list.  */
+	      if (unlikely (ipos != ipos_none || oper == oper_move))
+		{
+		  if (after_memberelem == newp)
+		    /* Since we remove this element even though we should
+		       insert everything after it, we in fact insert
+		       everything after the previous element.  */
+		    after_memberelem = all;
+
+		  goto next;
+		}
+	    }
+	}
+
+      if (all == NULL)
+	all = newp->next = newp;
+      else
+	{
+	  newp->next = all->next;
+	  all = all->next = newp;
+	}
+
+    next:
+      cmd = elf_next (subelf);
+      if (elf_end (subelf) != 0)
+	error (EXIT_FAILURE, 0, "%s: %s", arfname, elf_errmsg (-1));
+    }
+
+  if (oper != oper_qappend)
+    hdestroy ();
+
+ no_old:
+  if (member != NULL)
+    error (EXIT_FAILURE, 0, gettext ("position member %s not found"),
+	   member);
+
+  if (oper == oper_move)
+    {
+      /* Make sure all requested elements are found in the archive.  */
+      for (int cnt = 0; cnt < argc; ++cnt)
+	{
+	  if (found[cnt] == NULL)
+	    {
+	      fprintf (stderr, gettext ("%s: no entry %s in archive!\n"),
+		       AR, argv[cnt]);
+	      status = 1;
+	    }
+
+	  if (verbose)
+	    printf ("m - %s\n", argv[cnt]);
+	}
+    }
+  else
+    {
+      /* Open all the new files, get their sizes and add all symbols.  */
+      for (int cnt = 0; cnt < argc; ++cnt)
+	{
+	  const char *bname = basename (argv[cnt]);
+	  if (found[cnt] == NULL)
+	    {
+	      found[cnt] = alloca (sizeof (struct armem));
+	      found[cnt]->old_off = -1;
+
+	      size_t ar_namelen = strlen (argv[cnt]);
+	      if (ar_namelen > MAX_AR_NAME_LEN)
+		found[cnt]->long_name_off = arlib_add_long_name (&symtab,
+								 bname,
+								 ar_namelen);
+	      else
+		found[cnt]->long_name_off = -1l;
+	    }
+
+	  struct stat newst;
+	  Elf *newelf;
+	  int newfd = open (argv[cnt], O_RDONLY);
+	  if (newfd == -1)
+	    {
+	      error (0, errno, gettext ("cannot open %s"), argv[cnt]);
+	      status = 1;
+	    }
+	  else if (fstat (newfd, &newst) == -1)
+	    {
+	      error (0, errno, gettext ("cannot stat %s"), argv[cnt]);
+	      close (newfd);
+	      status = 1;
+	    }
+	  else if (!S_ISREG (newst.st_mode))
+	    {
+	      error (0, errno, gettext ("%s is no regular file"), argv[cnt]);
+	      close (newfd);
+	      status = 1;
+	    }
+	  else if (update_newer
+		   && found[cnt]->old_off != -1l
+		   && found[cnt]->sec > st.st_mtime)
+	    /* Do nothing, the file in the archive is younger.  */
+	    close (newfd);
+	  else if ((newelf = elf_begin (newfd, ELF_C_READ_MMAP, NULL))
+		   == NULL)
+	    {
+	      fprintf (stderr,
+		       gettext ("cannot get ELF descriptor for %s: %s\n"),
+		       argv[cnt], elf_errmsg (-1));
+	      status = 1;
+	    }
+	  else
+	    {
+	      if (verbose)
+		printf ("%c - %s\n",
+			found[cnt]->old_off == -1l ? 'a' : 'r', argv[cnt]);
+
+#ifdef DEBUG
+	      found[cnt]->elf = newelf;
+#endif
+	      found[cnt]->sec = newst.st_mtime;
+	      found[cnt]->uid = newst.st_uid;
+	      found[cnt]->gid = newst.st_gid;
+	      found[cnt]->mode = newst.st_mode;
+	      found[cnt]->name = basename (argv[cnt]);
+
+	      found[cnt]->mem = elf_rawfile (newelf, &found[cnt]->size);
+	      if (found[cnt] == NULL || elf_cntl (newelf, ELF_C_FDDONE) != 0)
+		error (EXIT_FAILURE, 0, gettext ("cannot read %s: %s"),
+		       argv[cnt], elf_errmsg (-1));
+
+	      close (newfd);
+
+	      /* Remember long file names.  */
+	      size_t bnamelen = strlen (bname);
+	      if (bnamelen > MAX_AR_NAME_LEN)
+		found[cnt]->long_name_off = arlib_add_long_name (&symtab,
+								 bname,
+								 bnamelen);
+	      else
+		found[cnt]->long_name_off = -1l;
+	    }
+	}
+    }
+
+  if (status != 0)
+    {
+#ifdef DEBUG
+      elf_end (elf);
+
+      arlib_fini (&symtab);
+
+      close (fd);
+#endif
+
+      return status;
+    }
+
+  /* If we have no entry point so far add at the end.  AFTER_MEMBERELEM
+     being NULL when adding before an entry means add at the beginning.  */
+  if (ipos != ipos_before && after_memberelem == NULL)
+    after_memberelem = all;
+
+  /* Convert the circular list into a normal list first.  */
+  if (all != NULL)
+    {
+      struct armem *tmp = all;
+      all = all->next;
+      tmp->next = NULL;
+    }
+
+  struct armem *last_added = after_memberelem;
+  for (int cnt = 0; cnt < argc; ++cnt)
+    if (oper != oper_replace || found[cnt]->old_off == -1)
+      {
+	if (last_added == NULL)
+	  {
+	    found[cnt]->next = all;
+	    last_added = all = found[cnt];
+	  }
+	else
+	  {
+	    found[cnt]->next = last_added->next;
+	    last_added = last_added->next = found[cnt];
+	  }
+      }
+
+  /* Finally compute the offset and add the symbols for the files
+     after the insert point.  */
+  if (likely (all != NULL))
+    for (struct armem *memp = all; memp != NULL; memp = memp->next)
+      {
+	memp->off = cur_off;
+
+	if (memp->mem == NULL)
+	  {
+	    Elf_Arhdr *arhdr;
+	    /* Fake initializing arhdr and subelf to keep gcc calm.  */
+	    asm ("" : "=m" (arhdr), "=m" (subelf));
+	    if (elf_rand (elf, memp->old_off) == 0
+		|| (subelf = elf_begin (fd, ELF_C_READ_MMAP, elf)) == NULL
+		|| (arhdr = elf_getarhdr (subelf)) == NULL)
+	      /* This should never happen since we already looked at the
+		 archive content.  But who knows...  */
+	      error (EXIT_FAILURE, 0, "%s: %s", arfname, elf_errmsg (-1));
+
+	    arlib_add_symbols (subelf, arfname, arhdr->ar_name, &symtab,
+			       cur_off);
+
+	    elf_end (subelf);
+	  }
+	else
+	  {
+	    arlib_add_symbols (memp->elf, arfname, memp->name, &symtab,
+			       cur_off);
+	  }
+
+	cur_off += (((memp->size + 1) & ~((off_t) 1))
+		    + sizeof (struct ar_hdr));
+      }
+
+  /* Now we have all the information for the symbol table and long
+     file name table.  Construct the final layout.  */
+  arlib_finalize (&symtab);
+
+  /* Create a new, temporary file in the same directory as the
+     original file.  */
+  char tmpfname[strlen (arfname) + 7];
+  strcpy (stpcpy (tmpfname, arfname), "XXXXXX");
+  int newfd;
+  if (fd != -1)
+    newfd = mkstemp (tmpfname);
+  else
+    {
+      newfd = open (arfname, O_RDWR | O_CREAT | O_EXCL, DEFFILEMODE);
+      if (newfd == -1 && errno == EEXIST)
+	/* Bah, first the file did not exist, now it does.  Restart.  */
+	return do_oper_insert (oper, arfname, argv, argc, member);
+    }
+  if (unlikely (newfd == -1))
+    goto nonew;
+
+  /* Create the header.  */
+  if (unlikely (write_retry (newfd, ARMAG, SARMAG) != SARMAG))
+    {
+    nonew_unlink:
+      if (fd != -1)
+	{
+	  // XXX Use /prof/self/fd/%d ???
+	  unlink (tmpfname);
+	  if (newfd != -1)
+	    close (newfd);
+	}
+    nonew:
+      error (0, errno, gettext ("cannot create new file"));
+      status = 1;
+      goto errout;
+    }
+
+  /* If the new archive is not empty we actually have something to do.  */
+  if (likely (all != NULL))
+    {
+      /* Write the symbol table or the long file name table or both.  */
+      if (symtab.symsnamelen != 0
+	  && ((write_retry (newfd, symtab.symsoff, symtab.symsofflen)
+	       != (ssize_t) symtab.symsofflen)
+	      || (write_retry (newfd, symtab.symsname, symtab.symsnamelen)
+		  != (ssize_t) symtab.symsnamelen)))
+	goto nonew_unlink;
+
+      if (symtab.longnameslen > sizeof (struct ar_hdr)
+	  && (write_retry (newfd, symtab.longnames, symtab.longnameslen)
+	      != (ssize_t) symtab.longnameslen))
+	goto nonew_unlink;
+
+      off_t start = -1;
+      off_t len = -1;
+
+      while (all != NULL)
+	{
+	  if (all->mem != NULL)
+	    {
+	      /* This is a new file.  If there is anything from the
+		 archive left to be written do it now.  */
+	      if (start != -1  && copy_content (elf, newfd, start, len))
+		goto nonew_unlink;
+
+	      start = -1;
+	      len = -1;
+
+	      /* Create the header.  */
+	      struct ar_hdr arhdr;
+	      char tmpbuf[sizeof (arhdr.ar_name) + 1];
+	      if (all->long_name_off == -1)
+		{
+		  size_t namelen = strlen (all->name);
+		  memset (mempcpy (arhdr.ar_name, all->name, namelen),
+			  ' ', sizeof (arhdr.ar_name) - namelen);
+		}
+	      else
+		{
+		  snprintf (tmpbuf, sizeof (arhdr.ar_name) + 1, "/%-*ld",
+			    (int) sizeof (arhdr.ar_name), all->long_name_off);
+		  memcpy (arhdr.ar_name, tmpbuf, sizeof (arhdr.ar_name));
+		}
+
+	      no0print (false, arhdr.ar_date, sizeof (arhdr.ar_date),
+			all->sec);
+	      no0print (false, arhdr.ar_uid, sizeof (arhdr.ar_uid), all->uid);
+	      no0print (false, arhdr.ar_gid, sizeof (arhdr.ar_gid), all->gid);
+	      no0print (true, arhdr.ar_mode, sizeof (arhdr.ar_mode),
+			all->mode);
+	      no0print (false, arhdr.ar_size, sizeof (arhdr.ar_size),
+			all->size);
+	      memcpy (arhdr.ar_fmag, ARFMAG, sizeof (arhdr.ar_fmag));
+
+	      if (unlikely (write_retry (newfd, &arhdr, sizeof (arhdr))
+			    != sizeof (arhdr)))
+		goto nonew_unlink;
+
+	      /* Now the file itself.  */
+	      if (unlikely (write_retry (newfd, all->mem, all->size)
+			    != (off_t) all->size))
+		goto nonew_unlink;
+
+	      /* Pad the file if its size is odd.  */
+	      if ((all->size & 1) != 0)
+		write (newfd, "\n", 1);
+	    }
+	  else
+	    {
+	      /* This is a member from the archive.  */
+	      if (write_member (all, &start, &len, elf, cur_off, newfd)
+		  != 0)
+		goto nonew_unlink;
+	    }
+
+	  all = all->next;
+	}
+
+      /* Write the last part.  */
+      if (start != -1 && copy_content (elf, newfd, start, len))
+	goto nonew_unlink;
+    }
+
+  /* Set the mode of the new file to the same values the original file
+     has.  */
+  if (fd != -1
+      && (fchmod (newfd, st.st_mode & ALLPERMS) != 0
+	  /* Never complain about fchown failing.  */
+	  || (fchown (newfd, st.st_uid, st.st_gid),
+	      close (newfd) != 0)
+	  || (newfd = -1, rename (tmpfname, arfname) != 0)))
+      goto nonew_unlink;
+
+ errout:
+#ifdef DEBUG
+  elf_end (elf);
+
+  arlib_fini (&symtab);
+
+  close (fd);
+#endif
+
+  return status;
+}
diff --git a/src/arlib.c b/src/arlib.c
new file mode 100644
index 00000000..a48afbce
--- /dev/null
+++ b/src/arlib.c
@@ -0,0 +1,269 @@
+/* Functions to handle creation of Linux archives.
+   Copyright (C) 2007 Red Hat, Inc.
+   Written by Ulrich Drepper <drepper@redhat.com>, 2007.
+
+   Red Hat elfutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by the
+   Free Software Foundation; version 2 of the License.
+
+   Red Hat elfutils is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with Red Hat elfutils; if not, write to the Free Software Foundation,
+   Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+
+   Red Hat elfutils is an included package of the Open Invention Network.
+   An included package of the Open Invention Network is a package for which
+   Open Invention Network licensees cross-license their patents.  No patent
+   license is granted, either expressly or impliedly, by designation as an
+   included package.  Should you wish to participate in the Open Invention
+   Network licensing program, please visit www.openinventionnetwork.com
+   <http://www.openinventionnetwork.com>.  */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <assert.h>
+#include <error.h>
+#include <gelf.h>
+#include <libintl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include <system.h>
+
+#include "arlib.h"
+
+
+/* Initialize ARLIB_SYMTAB structure.  */
+void
+arlib_init (struct arlib_symtab *symtab)
+{
+#define obstack_chunk_alloc xmalloc
+#define obstack_chunk_free free
+  obstack_init (&symtab->symsoffob);
+  obstack_init (&symtab->symsnameob);
+  obstack_init (&symtab->longnamesob);
+
+  /* We add the archive header here as well, that avoids allocating
+     another memory block.  */
+  struct ar_hdr ar_hdr;
+  memcpy (ar_hdr.ar_name, "/               ", sizeof (ar_hdr.ar_name));
+  /* Using snprintf here has a problem: the call always wants to add a
+     NUL byte.  We could use a trick whereby we specify the target
+     buffer size longer than it is and this would not actually fail,
+     since all the fields are consecutive and we fill them in in
+     sequence (i.e., the NUL byte gets overwritten).  But
+     _FORTIFY_SOURCE=2 would not let us play these games.  Therefore
+     we play it safe.  */
+  char tmpbuf[sizeof (ar_hdr.ar_date) + 1];
+  memcpy (ar_hdr.ar_date, tmpbuf,
+	  snprintf (tmpbuf, sizeof (tmpbuf), "%-*lld",
+		    (int) sizeof (ar_hdr.ar_date),
+		    (long long int) time (NULL)));
+  assert ((sizeof (struct ar_hdr)  % sizeof (uint32_t)) == 0);
+
+  /* Note the string for the ar_uid and ar_gid cases is longer than
+     necessary.  This does not matter since we copy only as much as
+     necessary but it helps the compiler to use the same string for
+     the ar_mode case.  */
+  memcpy (ar_hdr.ar_uid, "0       ", sizeof (ar_hdr.ar_uid));
+  memcpy (ar_hdr.ar_gid, "0       ", sizeof (ar_hdr.ar_gid));
+  memcpy (ar_hdr.ar_mode, "0       ", sizeof (ar_hdr.ar_mode));
+  memcpy (ar_hdr.ar_fmag, ARFMAG, sizeof (ar_hdr.ar_fmag));
+
+  /* Add the archive header to the file content.  */
+  obstack_grow (&symtab->symsoffob, &ar_hdr, sizeof (ar_hdr));
+
+  /* The first word in the offset table specifies the size.  Create
+     such an entry now.  The real value will be filled-in later.  For
+     all supported platforms the following is true.  */
+  assert (sizeof (uint32_t) == sizeof (int));
+  obstack_int_grow (&symtab->symsoffob, 0);
+
+  /* The long name obstack also gets its archive header.  As above,
+     some of the input strings are longer than required but we only
+     copy the necessary part.  */
+  memcpy (ar_hdr.ar_name, "//              ", sizeof (ar_hdr.ar_name));
+  memcpy (ar_hdr.ar_date, "            ", sizeof (ar_hdr.ar_date));
+  memcpy (ar_hdr.ar_uid, "            ", sizeof (ar_hdr.ar_uid));
+  memcpy (ar_hdr.ar_gid, "            ", sizeof (ar_hdr.ar_gid));
+  memcpy (ar_hdr.ar_mode, "            ", sizeof (ar_hdr.ar_mode));
+  /* The ar_size field will be filled in later and ar_fmag is already OK.  */
+  obstack_grow (&symtab->longnamesob, &ar_hdr, sizeof (ar_hdr));
+
+  /* All other members are zero.  */
+  symtab->symsofflen = 0;
+  symtab->symsoff = NULL;
+  symtab->symsnamelen = 0;
+  symtab->symsname = NULL;
+}
+
+
+/* Finalize ARLIB_SYMTAB content.  */
+void
+arlib_finalize (struct arlib_symtab *symtab)
+{
+  char tmpbuf[sizeof (((struct ar_hdr *) NULL)->ar_size) + 1];
+
+  symtab->longnameslen = obstack_object_size (&symtab->longnamesob);
+  if (symtab->longnameslen != sizeof (struct ar_hdr))
+    {
+      symtab->longnames = obstack_finish (&symtab->longnamesob);
+
+      memcpy (&((struct ar_hdr *) symtab->longnames)->ar_size, tmpbuf,
+	      snprintf (tmpbuf, sizeof (tmpbuf), "%-*zu",
+			(int) sizeof (((struct ar_hdr *) NULL)->ar_size),
+			symtab->longnameslen - sizeof (struct ar_hdr)));
+    }
+
+  symtab->symsofflen = obstack_object_size (&symtab->symsoffob);
+  assert (symtab->symsofflen % sizeof (uint32_t) == 0);
+  if (symtab->symsofflen != 0)
+    {
+      symtab->symsoff = (uint32_t *) obstack_finish (&symtab->symsoffob);
+
+      /* Fill in the number of offsets now.  */
+      symtab->symsoff[AR_HDR_WORDS] = le_bswap_32 ((symtab->symsofflen
+						    - sizeof (struct ar_hdr))
+						   / sizeof (uint32_t) - 1);
+    }
+
+  symtab->symsnamelen = obstack_object_size (&symtab->symsnameob);
+  if ((symtab->symsnamelen & 1) != 0)
+    {
+      /* Add one more NUL byte to make length even.  */
+      obstack_grow (&symtab->symsnameob, "", 1);
+      ++symtab->symsnamelen;
+    }
+  symtab->symsname = obstack_finish (&symtab->symsnameob);
+
+  /* Determine correction for the offsets in the symbol table.   */
+  off_t disp = 0;
+  if (symtab->symsnamelen > 0)
+    disp = symtab->symsofflen + symtab->symsnamelen;
+  if (symtab->longnameslen > sizeof (struct ar_hdr))
+    disp += symtab->longnameslen;
+
+  if (disp != 0 && symtab->symsoff != NULL)
+    {
+      uint32_t nsyms = le_bswap_32 (symtab->symsoff[AR_HDR_WORDS]);
+
+      for (uint32_t cnt = 1; cnt <= nsyms; ++cnt)
+	{
+	  uint32_t val = le_bswap_32 (symtab->symsoff[AR_HDR_WORDS + cnt]);
+	  val += disp;
+	  symtab->symsoff[AR_HDR_WORDS + cnt] = le_bswap_32 (val);
+	}
+    }
+
+  /* See comment for ar_date above.  */
+  memcpy (&((struct ar_hdr *) symtab->symsoff)->ar_size, tmpbuf,
+	  snprintf (tmpbuf, sizeof (tmpbuf), "%-*zu",
+		    (int) sizeof (((struct ar_hdr *) NULL)->ar_size),
+		    symtab->symsofflen + symtab->symsnamelen
+		    - sizeof (struct ar_hdr)));
+}
+
+
+/* Free resources for ARLIB_SYMTAB.  */
+void
+arlib_fini (struct arlib_symtab *symtab)
+{
+  obstack_free (&symtab->symsoffob, NULL);
+  obstack_free (&symtab->symsnameob, NULL);
+  obstack_free (&symtab->longnamesob, NULL);
+}
+
+
+/* Add name a file offset of a symbol.  */
+void
+arlib_add_symref (struct arlib_symtab *symtab, const char *symname,
+		  off_t symoff)
+{
+  /* For all supported platforms the following is true.  */
+  assert (sizeof (uint32_t) == sizeof (int));
+  obstack_int_grow (&symtab->symsoffob, (int) le_bswap_32 (symoff));
+
+  size_t symname_len = strlen (symname) + 1;
+  obstack_grow (&symtab->symsnameob, symname, symname_len);
+}
+
+
+/* Add symbols from ELF with value OFFSET to the symbol table SYMTAB.  */
+void
+arlib_add_symbols (Elf *elf, const char *arfname, const char *membername,
+		   struct arlib_symtab *symtab, off_t off)
+{
+  if (sizeof (off) > sizeof (uint32_t) && off > ~((uint32_t) 0))
+    /* The archive is too big.  */
+    error (EXIT_FAILURE, 0, gettext ("the archive '%s' is too large"),
+	   arfname);
+
+  /* We only add symbol tables for ELF files.  It makes not much sense
+     to add symbols from executables but we do so for compatibility.
+     For DSOs and executables we use the dynamic symbol table, for
+     relocatable files all the DT_SYMTAB tables.  */
+  if (elf_kind (elf) != ELF_K_ELF)
+    return;
+
+  GElf_Ehdr ehdr_mem;
+  GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
+  if (ehdr == NULL)
+    error (EXIT_FAILURE, 0, gettext ("cannot read ELF header of %s(%s): %s"),
+	   arfname, membername, elf_errmsg (-1));
+
+  GElf_Word symtype;
+  if (ehdr->e_type == ET_REL)
+    symtype = SHT_SYMTAB;
+  else if (ehdr->e_type == ET_EXEC || ehdr->e_type == ET_DYN)
+    symtype = SHT_DYNSYM;
+  else
+    /* We do not handle that type.  */
+    return;
+
+  /* Iterate over all sections.  */
+  Elf_Scn *scn = NULL;
+  while ((scn = elf_nextscn (elf, scn)) != NULL)
+    {
+      /* Get the section header.  */
+      GElf_Shdr shdr_mem;
+      GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
+      if (shdr == NULL)
+	continue;
+
+      if (shdr->sh_type != symtype)
+	continue;
+
+      Elf_Data *data = elf_getdata (scn, NULL);
+      if (data == NULL)
+	continue;
+
+      int nsyms = shdr->sh_size / shdr->sh_entsize;
+      for (int ndx = shdr->sh_info; ndx < nsyms; ++ndx)
+	{
+	  GElf_Sym sym_mem;
+	  GElf_Sym *sym = gelf_getsym (data, ndx, &sym_mem);
+	  if (sym == NULL)
+	    continue;
+
+	  /* Ignore undefined symbols.  */
+	  if (sym->st_shndx == SHN_UNDEF)
+	    continue;
+
+	  /* Use this symbol.  */
+	  const char *symname = elf_strptr (elf, shdr->sh_link, sym->st_name);
+	  if (symname != NULL)
+	    arlib_add_symref (symtab, symname, off);
+	}
+
+      /* Only relocatable files can have more than one symbol table.  */
+      if (ehdr->e_type != ET_REL)
+	break;
+    }
+}
diff --git a/src/arlib.h b/src/arlib.h
new file mode 100644
index 00000000..ab1be0c6
--- /dev/null
+++ b/src/arlib.h
@@ -0,0 +1,95 @@
+/* Copyright (C) 2007 Red Hat, Inc.
+   Written by Ulrich Drepper <drepper@redhat.com>, 2007.
+
+   Red Hat elfutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by the
+   Free Software Foundation; version 2 of the License.
+
+   Red Hat elfutils is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with Red Hat elfutils; if not, write to the Free Software Foundation,
+   Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+
+   Red Hat elfutils is an included package of the Open Invention Network.
+   An included package of the Open Invention Network is a package for which
+   Open Invention Network licensees cross-license their patents.  No patent
+   license is granted, either expressly or impliedly, by designation as an
+   included package.  Should you wish to participate in the Open Invention
+   Network licensing program, please visit www.openinventionnetwork.com
+   <http://www.openinventionnetwork.com>.  */
+
+#ifndef _ARLIB_H
+#define _ARLIB_H	1
+
+#include <ar.h>
+#include <byteswap.h>
+#include <endian.h>
+#include <libelf.h>
+#include <obstack.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <sys/types.h>
+
+
+/* Maximum length of a file name that fits directly into the ar header.  */
+#define MAX_AR_NAME_LEN (sizeof (((struct ar_hdr *) NULL)->ar_name))
+
+
+/* Words matching in size to archive header.  */
+#define AR_HDR_WORDS (sizeof (struct ar_hdr) / sizeof (uint32_t))
+
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+# define le_bswap_32(val) bswap_32 (val)
+#else
+# define le_bswap_32(val) (val)
+#endif
+
+
+/* Symbol table type.  */
+struct arlib_symtab
+{
+  /* Symbol table handling.  */
+  struct obstack symsoffob;
+  struct obstack symsnameob;
+  size_t symsofflen;
+  uint32_t *symsoff;
+  size_t symsnamelen;
+  char *symsname;
+
+  /* Long filename handling.  */
+  struct obstack longnamesob;
+  size_t longnameslen;
+  char *longnames;
+};
+
+
+/* Initialize ARLIB_SYMTAB structure.  */
+extern void arlib_init (struct arlib_symtab *symtab);
+
+
+/* Finalize ARLIB_SYMTAB content.  */
+extern void arlib_finalize (struct arlib_symtab *symtab);
+
+/* Free resources for ARLIB_SYMTAB.  */
+extern void arlib_fini (struct arlib_symtab *symtab);
+
+/* Add symbols from ELF with value OFFSET to the symbol table SYMTAB.  */
+extern void arlib_add_symbols (Elf *elf, const char *arfname,
+			       const char *membername,
+			       struct arlib_symtab *symtab, off_t off);
+
+/* Add name a file offset of a symbol.  */
+extern void arlib_add_symref (struct arlib_symtab *symtab, const char *symname,
+			      off_t symoff);
+
+/* Add long file name FILENAME of length FILENAMELEN to the symbol table
+   SYMTAB.  Return the offset into the long file name table.  */
+extern long int arlib_add_long_name (struct arlib_symtab *symtab,
+				     const char *filename, size_t filenamelen);
+
+#endif	/* arlib.h */
diff --git a/src/arlib2.c b/src/arlib2.c
new file mode 100644
index 00000000..cb1e1db3
--- /dev/null
+++ b/src/arlib2.c
@@ -0,0 +1,51 @@
+/* Functions to handle creation of Linux archives.
+   Copyright (C) 2007 Red Hat, Inc.
+   Written by Ulrich Drepper <drepper@redhat.com>, 2007.
+
+   Red Hat elfutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by the
+   Free Software Foundation; version 2 of the License.
+
+   Red Hat elfutils is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with Red Hat elfutils; if not, write to the Free Software Foundation,
+   Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+
+   Red Hat elfutils is an included package of the Open Invention Network.
+   An included package of the Open Invention Network is a package for which
+   Open Invention Network licensees cross-license their patents.  No patent
+   license is granted, either expressly or impliedly, by designation as an
+   included package.  Should you wish to participate in the Open Invention
+   Network licensing program, please visit www.openinventionnetwork.com
+   <http://www.openinventionnetwork.com>.  */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <error.h>
+#include <libintl.h>
+#include <limits.h>
+#include <string.h>
+#include <sys/param.h>
+
+#include "arlib.h"
+
+
+/* Add long file name FILENAME of length FILENAMELEN to the symbol table
+   SYMTAB.  Return the offset into the long file name table.  */
+long int
+arlib_add_long_name (struct arlib_symtab *symtab, const char *filename,
+		     size_t filenamelen)
+{
+  int retval = obstack_object_size (&symtab->longnamesob);
+
+  obstack_grow (&symtab->longnamesob, filename, filenamelen);
+  obstack_grow (&symtab->longnamesob, "/\n", 2);
+
+  return retval;
+}
diff --git a/src/elflint.c b/src/elflint.c
index f887ac3c..79e52299 100644
--- a/src/elflint.c
+++ b/src/elflint.c
@@ -731,9 +731,22 @@ section [%2d] '%s': symbol %zu: function in COMMON section is nonsense\n"),
 		    {
 		      if ((sym->st_value - destshdr->sh_addr)
 			  > destshdr->sh_size)
-			ERROR (gettext ("\
+			{
+			  /* GNU ld has severe bugs.  When it decides to remove
+			     empty sections it leaves symbols referencing them
+			     behind.  These are symbols in .symtab.  */
+			  if (!gnuld
+			      || strcmp (section_name (ebl, idx), ".symtab")
+			      || (strcmp (name, "__preinit_array_start") != 0
+				  && strcmp (name, "__preinit_array_end") != 0
+				  && strcmp (name, "__init_array_start") != 0
+				  && strcmp (name, "__init_array_end") != 0
+				  && strcmp (name, "__fini_array_start") != 0
+				  && strcmp (name, "__fini_array_end") != 0))
+			    ERROR (gettext ("\
 section [%2d] '%s': symbol %zu: st_value out of bounds\n"),
-			       idx, section_name (ebl, idx), cnt);
+				   idx, section_name (ebl, idx), cnt);
+			}
 		      else if ((sym->st_value - destshdr->sh_addr
 				+ sym->st_size) > destshdr->sh_size)
 			ERROR (gettext ("\
diff --git a/src/ranlib.c b/src/ranlib.c
index fd4509d7..0a8667d3 100644
--- a/src/ranlib.c
+++ b/src/ranlib.c
@@ -31,8 +31,6 @@
 #include <ar.h>
 #include <argp.h>
 #include <assert.h>
-#include <byteswap.h>
-#include <endian.h>
 #include <errno.h>
 #include <error.h>
 #include <fcntl.h>
@@ -44,19 +42,14 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdio_ext.h>
-#include <time.h>
 #include <unistd.h>
+#include <sys/mman.h>
 #include <sys/param.h>
 #include <sys/stat.h>
 
 #include <system.h>
 
-
-#if __BYTE_ORDER == __LITTLE_ENDIAN
-# define le_bswap_32(val) bswap_32 (val)
-#else
-# define le_bswap_32(val) (val)
-#endif
+#include "arlib.h"
 
 
 /* Prototypes for local functions.  */
@@ -83,13 +76,10 @@ static const char doc[] = N_("Generate an index to speed access to archives.");
 /* Strings for arguments in help texts.  */
 static const char args_doc[] = N_("ARCHIVE");
 
-/* Prototype for option handler.  */
-static error_t parse_opt (int key, char *arg, struct argp_state *state);
-
 /* Data structure to communicate with argp functions.  */
-static struct argp argp =
+static const struct argp argp =
 {
-  options, parse_opt, args_doc, doc, NULL, NULL, NULL
+  options, NULL, args_doc, doc, NULL, NULL, NULL
 };
 
 
@@ -152,141 +142,20 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
 }
 
 
-/* Handle program arguments.  */
-static error_t
-parse_opt (int key, char *arg __attribute__ ((unused)),
-	   struct argp_state *state __attribute__ ((unused)))
-{
-  switch (key)
-    {
-    default:
-      return ARGP_ERR_UNKNOWN;
-    }
-  return 0;
-}
-
-
-static struct obstack offsob;
-size_t offs_len;
-static struct obstack namesob;
-size_t names_len;
-
-
-/* Add all exported, defined symbols from the given section to the table.  */
-static void
-add_symbols (Elf *elf, const char *fname, off_t off, Elf_Scn *scn,
-	     GElf_Shdr *shdr)
-{
-  if (sizeof (off) > sizeof (uint32_t) && off > ~((uint32_t) 0))
-    /* The archive is too big.  */
-    error (EXIT_FAILURE, 0, gettext ("the archive '%s' is too large"), fname);
-
-  Elf_Data *data = elf_getdata (scn, NULL);
-  assert (data->d_size == shdr->sh_size);
-
-  /* We can skip the local symbols in the table.  */
-  for (int cnt = shdr->sh_info; cnt < (int) (shdr->sh_size / shdr->sh_entsize);
-       ++cnt)
-    {
-      GElf_Sym sym_mem;
-      GElf_Sym *sym = gelf_getsym (data, cnt, &sym_mem);
-      if (sym == NULL)
-	/* Should never happen.  */
-	continue;
-
-      /* Ignore undefined symbols.  */
-      if (sym->st_shndx == SHN_UNDEF)
-	continue;
-
-      /* For all supported platforms the following is true.  */
-      assert (sizeof (uint32_t) == sizeof (int));
-      obstack_int_grow (&offsob, (int) le_bswap_32 (off));
-      offs_len += sizeof (uint32_t);
-
-      const char *symname = elf_strptr (elf, shdr->sh_link, sym->st_name);
-      size_t symname_len = strlen (symname) + 1;
-      obstack_grow (&namesob, symname, symname_len);
-      names_len += symname_len;
-    }
-}
-
-
-/* Look through ELF file and collect all symbols available for
-   linking.  If available, we use the dynamic symbol section.
-   Otherwise the normal one.  Relocatable files are allowed to have
-   multiple symbol tables.  */
-static void
-handle_elf (Elf *elf, const char *arfname, off_t off)
-{
-  GElf_Ehdr ehdr_mem;
-  GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
-  assert (ehdr != NULL);
-
-  if (ehdr->e_type == ET_REL)
-    {
-      Elf_Scn *scn = NULL;
-      while ((scn = elf_nextscn (elf, scn)) != NULL)
-	{
-	  GElf_Shdr shdr_mem;
-	  GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
-	  if (shdr != NULL && shdr->sh_type == SHT_SYMTAB)
-	    add_symbols (elf, arfname, off, scn, shdr);
-	}
-    }
-  else
-    {
-      Elf_Scn *symscn = NULL;
-      GElf_Shdr *symshdr = NULL;
-      Elf_Scn *scn = NULL;
-      GElf_Shdr shdr_mem;
-      while ((scn = elf_nextscn (elf, scn)) != NULL)
-	{
-	  GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
-	  symshdr = NULL;
-	  if (shdr != NULL)
-	    {
-	      if (shdr->sh_type == SHT_DYNSYM)
-		{
-		  symscn = scn;
-		  symshdr = shdr;
-		  break;
-		}
-	      if (shdr->sh_type == SHT_SYMTAB)
-		{
-		  /* There better be only one symbol table in
-		     executables in DSOs.  */
-		  assert (symscn == NULL);
-		  symscn = scn;
-		  symshdr = shdr;
-		}
-	    }
-	}
-
-      add_symbols (elf, arfname, off, symscn,
-		   symshdr ?: gelf_getshdr (scn, &shdr_mem));
-    }
-}
-
-
 static int
-copy_content (int oldfd, int newfd, off_t off, size_t n)
+copy_content (Elf *elf, int newfd, off_t off, size_t n)
 {
-  while (n > 0)
-    {
-      char buf[32768];
+  size_t len;
+  char *rawfile = elf_rawfile (elf, &len);
 
-      ssize_t nread = pread_retry (oldfd, buf, MIN (sizeof (buf), n), off);
-      if (unlikely (nread <= 0))
-	return 1;
+  assert (off + n <= len);
 
-      if (write_retry (newfd, buf, nread) != nread)
-	return 1;
-
-      n -= nread;
-      off += nread;
-    }
+  /* Tell the kernel we will read all the pages sequentially.  */
+  size_t ps = sysconf (_SC_PAGESIZE);
+  if (n > 2 * ps)
+    posix_madvise (rawfile + (off & ~(ps - 1)), n, POSIX_MADV_SEQUENTIAL);
 
-  return 0;
+  return write_retry (newfd, rawfile + off, n) != (ssize_t) n;
 }
 
 
@@ -328,84 +197,64 @@ handle_file (const char *fname)
       return 1;
     }
 
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-  obstack_init (&offsob);
-  offs_len = 0;
-  obstack_init (&namesob);
-  names_len = 0;
-
-  /* The first word in the offset table specifies the size.  Create
-     such an entry now.  The real value will be filled-in later.  For
-     all supported platforms the following is true.  */
-  assert (sizeof (uint32_t) == sizeof (int));
-  obstack_int_grow (&offsob, 0);
-  offs_len += sizeof (uint32_t);
+  struct arlib_symtab symtab;
+  arlib_init (&symtab);
 
   /* Iterate over the content of the archive.  */
   off_t index_off = -1;
   size_t index_size = 0;
+  off_t cur_off = SARMAG;
   Elf *elf;
   Elf_Cmd cmd = ELF_C_READ_MMAP;
   while ((elf = elf_begin (fd, cmd, arelf)) != NULL)
     {
       Elf_Arhdr *arhdr = elf_getarhdr (elf);
       assert (arhdr != NULL);
-      off_t off = elf_getaroff (elf);
 
-      Elf_Kind kind = elf_kind (elf);
-      if (kind == ELF_K_ELF)
-	handle_elf (elf, fname, off);
-#if 0
-      else if (kind == ELF_K_AR)
-	{
-	  // XXX Should we implement this?
-	}
-#endif
       /* If this is the index, remember the location.  */
-      else if (strcmp (arhdr->ar_name, "/") == 0)
+      if (strcmp (arhdr->ar_name, "/") == 0)
 	{
-	  index_off = off;
+	  index_off = elf_getaroff (elf);
 	  index_size = arhdr->ar_size;
 	}
+      else
+	{
+	  arlib_add_symbols (elf, fname, arhdr->ar_name, &symtab, cur_off);
+	  cur_off += (((arhdr->ar_size + 1) & ~((off_t) 1))
+		      + sizeof (struct ar_hdr));
+	}
 
       /* Get next archive element.  */
       cmd = elf_next (elf);
       if (elf_end (elf) != 0)
-	error (0, 0,
-	       gettext (" error while freeing sub-ELF descriptor: %s\n"),
+	error (0, 0, gettext ("error while freeing sub-ELF descriptor: %s"),
 	       elf_errmsg (-1));
     }
 
-  elf_end (arelf);
-  uint32_t *offs_arr = obstack_finish (&offsob);
-  assert (offs_len % sizeof (uint32_t) == 0);
-  if ((names_len & 1) != 0)
-    {
-      /* Add one more NUL byte to make length even.  */
-      obstack_grow (&namesob, "", 1);
-      ++names_len;
-    }
-  const char *names_str = obstack_finish (&namesob);
+  arlib_finalize (&symtab);
 
   /* If the file contains no symbols we need not do anything.  */
-  if (names_len != 0
+  int status = 0;
+  if (symtab.symsnamelen != 0
       /* We have to rewrite the file also if it initially had an index
 	 but now does not need one anymore.  */
-      || (names_len == 0 && index_off != -1))
+      || (symtab.symsnamelen == 0 && index_size != 0))
     {
       /* Create a new, temporary file in the same directory as the
 	 original file.  */
-      char tmpfname[strlen (fname) + 8];
-      strcpy (stpcpy (tmpfname, fname), ".XXXXXX");
+      char tmpfname[strlen (fname) + 7];
+      strcpy (stpcpy (tmpfname, fname), "XXXXXX");
       int newfd = mkstemp (tmpfname);
-      if (newfd == -1)
-      nonew:
-	error (0, errno, gettext ("cannot create new file"));
+      if (unlikely (newfd == -1))
+	{
+	nonew:
+	  error (0, errno, gettext ("cannot create new file"));
+	  status = 1;
+	}
       else
 	{
 	  /* Create the header.  */
-	  if (write_retry (newfd, ARMAG, SARMAG) != SARMAG)
+	  if (unlikely (write_retry (newfd, ARMAG, SARMAG) != SARMAG))
 	    {
 	      // XXX Use /prof/self/fd/%d ???
 	    nonew_unlink:
@@ -415,62 +264,6 @@ handle_file (const char *fname)
 	      goto nonew;
 	    }
 
-	  struct ar_hdr ar_hdr;
-	  memcpy (ar_hdr.ar_name, "/               ", sizeof (ar_hdr.ar_name));
-	  /* Using snprintf here has a problem: the call always wants
-	     to add a NUL byte.  We could use a trick whereby we
-	     specify the target buffer size longer than it is and this
-	     would not actually fail, since all the fields are
-	     consecutive and we fill them in in sequence (i.e., the
-	     NUL byte gets overwritten).  But _FORTIFY_SOURCE=2 would
-	     not let us play these games.  Therefore we play it
-	     safe.  */
-	  char tmpbuf[MAX (sizeof (ar_hdr.ar_date), sizeof (ar_hdr.ar_size))
-		      + 1];
-	  memcpy (ar_hdr.ar_date, tmpbuf,
-		  snprintf (tmpbuf, sizeof (tmpbuf), "%-*lld",
-			    (int) sizeof (ar_hdr.ar_date),
-			    (long long int) time (NULL)));
-
-	  /* Note the string for the ar_uid and ar_gid cases is longer
-	     than necessary.  This does not matter since we copy only as
-	     much as necessary but it helps the compiler to use the same
-	     string for the ar_mode case.  */
-	  memcpy (ar_hdr.ar_uid, "0       ", sizeof (ar_hdr.ar_uid));
-	  memcpy (ar_hdr.ar_gid, "0       ", sizeof (ar_hdr.ar_gid));
-	  memcpy (ar_hdr.ar_mode, "0       ", sizeof (ar_hdr.ar_mode));
-
-	  /* See comment for ar_date above.  */
-	  memcpy (ar_hdr.ar_size, tmpbuf,
-		  snprintf (tmpbuf, sizeof (tmpbuf), "%-*zu",
-			    (int) sizeof (ar_hdr.ar_size),
-			    offs_len + names_len));
-	  memcpy (ar_hdr.ar_fmag, ARFMAG, sizeof (ar_hdr.ar_fmag));
-
-	  /* Fill in the number of offsets now.  */
-	  offs_arr[0] = le_bswap_32 (offs_len / sizeof (uint32_t) - 1);
-
-	  /* Adjust the offset values for the name index size (if
-	     necessary).  */
-	  off_t disp = (offs_len + ((names_len + 1) & ~1ul)
-			- ((index_size + 1) & ~1ul));
-	  /* If there was no index so far but one is needed now we
-	     have to take the archive header into account.  */
-	  if (index_off == -1 && names_len != 0)
-	    disp += sizeof (struct ar_hdr);
-	  if (disp != 0)
-	    for (size_t cnt = 1; cnt < offs_len / sizeof (uint32_t); ++cnt)
-	      {
-		uint32_t val;
-		val = le_bswap_32 (offs_arr[cnt]);
-
-		if (val > index_off)
-		  {
-		    val += disp;
-		    offs_arr[cnt] = le_bswap_32 (val);
-		  }
-	      }
-
 	  /* Create the new file.  There are three parts as far we are
 	     concerned: 1. original context before the index, 2. the
 	     new index, 3. everything after the new index.  */
@@ -481,30 +274,34 @@ handle_file (const char *fname)
 	  else
 	    rest_off = SARMAG;
 
-	  if ((index_off > SARMAG
-	       && copy_content (fd, newfd, SARMAG, index_off - SARMAG))
-	      || (names_len != 0
-		  && ((write_retry (newfd, &ar_hdr, sizeof (ar_hdr))
-		       != sizeof (ar_hdr))
-		      || (write_retry (newfd, offs_arr, offs_len)
-			  != (ssize_t) offs_len)
-		      || (write_retry (newfd, names_str, names_len)
-			  != (ssize_t) names_len)))
-	      || copy_content (fd, newfd, rest_off, st.st_size - rest_off)
+	  if ((symtab.symsnamelen != 0
+	       && ((write_retry (newfd, symtab.symsoff,
+				 symtab.symsofflen)
+		    != (ssize_t) symtab.symsofflen)
+		   || (write_retry (newfd, symtab.symsname,
+				    symtab.symsnamelen)
+		       != (ssize_t) symtab.symsnamelen)))
+	      /* Even if the original file had content before the
+		 symbol table, we write it in the correct order.  */
+	      || (index_off > SARMAG
+		  && copy_content (arelf, newfd, SARMAG, index_off - SARMAG))
+	      || copy_content (arelf, newfd, rest_off, st.st_size - rest_off)
 	      /* Set the mode of the new file to the same values the
 		 original file has.  */
 	      || fchmod (newfd, st.st_mode & ALLPERMS) != 0
-	      || fchown (newfd, st.st_uid, st.st_gid) != 0
-	      || close (newfd) != 0
+	      /* Never complain about fchown failing.  */
+	      || (fchown (newfd, st.st_uid, st.st_gid),
+		  close (newfd) != 0)
 	      || (newfd = -1, rename (tmpfname, fname) != 0))
 	    goto nonew_unlink;
 	}
     }
 
-  obstack_free (&offsob, NULL);
-  obstack_free (&namesob, NULL);
+  elf_end (arelf);
+
+  arlib_fini (&symtab);
 
   close (fd);
 
-  return 0;
+  return status;
 }
diff --git a/tests/ChangeLog b/tests/ChangeLog
index cce03fbe..2aaba2fa 100644
--- a/tests/ChangeLog
+++ b/tests/ChangeLog
@@ -1,3 +1,10 @@
+2007-02-04  Ulrich Drepper  <drepper@redhat.com>
+
+	* arls.c: New file.
+	* Makefile (noinst_PROGRAMS): Add arls.
+
+	* run-ranlib-test2.sh: Fix type in comment.
+
 2007-01-10  Ulrich Drepper  <drepper@redhat.com>
 
 	* run-elflint-self.sh (runtest): Show which file has the problem.
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 93a2f8e3..bd56f7b7 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -59,7 +59,7 @@ noinst_PROGRAMS = arextract arsymtest newfile saridx scnnames sectiondump \
 		  get-aranges allfcts line2addr addrscopes funcscopes \
 		  show-abbrev hash newscn ecp dwflmodtest \
 		  find-prologues funcretval allregs rdwrmmap \
-		  dwfl-bug-addr-overflow
+		  dwfl-bug-addr-overflow arls
 # get-ciefde
 asm_TESTS = asm-tst1 asm-tst2 asm-tst3 asm-tst4 asm-tst5 \
 	    asm-tst6 asm-tst7 asm-tst8 asm-tst9
@@ -201,6 +201,7 @@ asm_tst9_LDADD = $(libasm) $(libebl) $(libelf) $(libmudflap) -ldl
 dwflmodtest_LDADD = $(libdw) $(libebl) $(libelf) $(libmudflap) -ldl
 rdwrmmap_LDADD = $(libelf)
 dwfl_bug_addr_overflow_LDADD = $(libdw) $(libebl) $(libelf) $(libmudflap) -ldl
+arls_LDADD = $(libelf) $(libmudflap)
 
 CLEANFILES = xxx *.gcno *.gcda *gconv
 
diff --git a/tests/arls.c b/tests/arls.c
new file mode 100644
index 00000000..79b867da
--- /dev/null
+++ b/tests/arls.c
@@ -0,0 +1,91 @@
+#include <ar.h>
+#include <fcntl.h>
+#include <libelf.h>
+#include <stdio.h>
+#include <unistd.h>
+
+
+static int handle (const char *fname);
+
+
+int
+main (int argc, char *argv[])
+{
+  elf_version (EV_CURRENT);
+
+  int result = 0;
+  if (argc == 1)
+    result = handle ("a.out");
+  else
+    for (int i = 1; i < argc; ++i)
+      result |= handle (argv[1]);
+
+  return result;
+}
+
+
+static int
+handle (const char *fname)
+{
+  int fd = open (fname, O_RDONLY);
+  if (fd == -1)
+    {
+      printf ("cannot open '%s': %m\n", fname);
+      return 1;
+    }
+
+  Elf *elf = elf_begin (fd, ELF_C_READ_MMAP, NULL);
+  if (elf == NULL)
+    {
+      printf ("cannot get ELF handling for '%s': %s\n",
+	      fname, elf_errmsg (-1));
+      close (fd);
+      return 1;
+    }
+
+  if (elf_kind (elf) != ELF_K_AR)
+    {
+      printf ("'%s' is no archive\n", fname);
+      elf_end (elf);
+      close (fd);
+      return 1;
+    }
+
+  printf ("%s:\n", fname);
+  Elf *subelf = NULL;
+  Elf_Cmd cmd = ELF_C_READ_MMAP;
+  while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
+    {
+      Elf_Arhdr *arhdr = elf_getarhdr (subelf);
+      if (arhdr == NULL)
+	{
+	  printf ("cannot get archive header in '%s': %s\n",
+		  fname, elf_errmsg (-1));
+	  elf_end (subelf);
+	  elf_end (elf);
+	  close (fd);
+	  return 1;
+	}
+
+      off_t off = elf_getaroff (subelf);
+
+      printf ("\nOffset    %llu\n"
+	      "  Name    %s\n"
+	      "  Date    %ld\n"
+	      "  UID     %d\n"
+	      "  GID     %d\n"
+	      "  Mode    %o\n"
+	      "  Size    %lld\n",
+	      (unsigned long long int) off,
+	      arhdr->ar_name, (long int) arhdr->ar_date, (int) arhdr->ar_uid,
+	      (int) arhdr->ar_gid,
+	      (int) arhdr->ar_mode, (long long int) arhdr->ar_size);
+
+      cmd = elf_next (subelf);
+      elf_end (subelf);
+    }
+
+  close (fd);
+
+  return 0;
+}
diff --git a/tests/run-ranlib-test2.sh b/tests/run-ranlib-test2.sh
index 19b081d6..87040376 100755
--- a/tests/run-ranlib-test2.sh
+++ b/tests/run-ranlib-test2.sh
@@ -34,7 +34,7 @@ testfiles $original $indexed
 testrun ../src/ranlib $original
 
 if test -z "$noindex"; then
-  # The data in the index is different.  The reference file has it blanked
+  # The date in the index is different.  The reference file has it blanked
   # out, we do the same here.
   echo "            " |
   dd of=$original seek=24 bs=1 count=12 conv=notrunc 2>/dev/null