diff --git a/tests/elfstrmerge.c b/tests/elfstrmerge.c
new file mode 100644
index 0000000..3bb90c4
--- /dev/null
+++ b/tests/elfstrmerge.c
@@ -0,0 +1,675 @@
+/* Merge string sections.
+   Copyright (C) 2015, 2016 Red Hat, Inc.
+   This file is part of elfutils.
+
+   This file 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; either version 3 of the License, or
+   (at your option) any later version.
+
+   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 this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include <config.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <error.h>
+#include <stdio.h>
+#include <inttypes.h>
+#include <unistd.h>
+
+#include <system.h>
+#include <gelf.h>
+#include ELFUTILS_HEADER(dwelf)
+#include "elf-knowledge.h"
+
+/* The original ELF file.  */
+static int fd = -1;
+static Elf *elf = NULL;
+static bool replace;
+
+/* The new ELF file.  */
+static char *fnew = NULL;
+static int fdnew = -1;
+static Elf *elfnew = NULL;
+
+/* The merged string table.  */
+static Dwelf_Strtab *strings = NULL;
+
+/* Section name strents.  */
+static Dwelf_Strent **scnstrents = NULL;
+
+/* Symbol name strends.  */
+static Dwelf_Strent **symstrents = NULL;
+
+/* New ELF file buffers.  */
+static Elf_Data newstrtabdata = { .d_buf = NULL };
+static size_t newshnums = 0;
+static void **newscnbufs = NULL;
+
+/* Release all files and resources allocated.  */
+static void
+release (void)
+{
+  /* The new string table.  */
+  if (strings != NULL)
+    dwelf_strtab_free (strings);
+
+  free (scnstrents);
+  free (symstrents);
+  free (newstrtabdata.d_buf);
+
+  /* Any new data buffers allocated.  */
+  for (size_t i = 0; i < newshnums; i++)
+    free (newscnbufs[i]);
+  free (newscnbufs);
+
+  /* The new ELF file.  */
+  if (fdnew != -1)
+    {
+      unlink (fnew);
+      elf_end (elfnew);
+      close (fdnew);
+    }
+  // Don't release, we might need it in the error message.
+  // if (replace)
+  //   free (fnew);
+
+  /* The original ELF file.  */
+  elf_end (elf);
+  close (fd);
+}
+
+/* The various ways we can fail... Cleanup and show some message to
+   the user.  The file name may be NULL.  */
+static void __attribute__ ((noreturn))
+fail (const char *msg, const char *fname)
+{
+  release ();
+  if (fname != NULL)
+    error (1, 0, "%s: %s", fname, msg);
+  else
+    error (1, 0, "%s", msg);
+  abort();
+}
+
+static void __attribute__ ((noreturn))
+fail_errno (const char *msg, const char *fname)
+{
+  release ();
+  if (fname != NULL)
+    error (1, errno, "%s: %s", fname, msg);
+  else
+    error (1, errno, "%s", msg);
+  abort();
+}
+
+static void __attribute__ ((noreturn))
+fail_idx (const char *msg, const char *fname, size_t idx)
+{
+  release ();
+  if (fname != NULL)
+    error (1, 0, "%s: %s %zd", fname, msg, idx);
+  else
+    error (1, 0, "%s %zd", msg, idx);
+  abort();
+}
+
+static void __attribute__ ((noreturn))
+fail_elf (const char *msg, const char *fname)
+{
+  release ();
+  if (fname != NULL)
+    error (1, 0, "%s: %s: %s", fname, msg, elf_errmsg (-1));
+  else
+    error (1, 0, "%s: %s", msg, elf_errmsg (-1));
+  abort();
+}
+
+static void __attribute__ ((noreturn))
+fail_elf_idx (const char *msg, const char *fname, size_t idx)
+{
+  release ();
+  if (fname != NULL)
+    error (1, 0, "%s: %s %zd: %s", fname, msg, idx, elf_errmsg (-1));
+  else
+    error (1, 0, "%s %zd: %s", msg, idx, elf_errmsg (-1));
+  abort();
+}
+
+int
+main (int argc, char **argv)
+{
+  elf_version (EV_CURRENT);
+
+  /* Basic command line handling.  Need to replace the input file?  */
+  if ((argc != 2 && argc != 4)
+      || (argc == 4 && strcmp (argv[1], "-o") != 0))
+    fail ("Usage argument: [-o <outputfile>] <inputfile>", NULL);
+  replace = argc == 2;
+
+  /* Get the ELF file.  */
+  const char *fname;
+  if (replace)
+    fname = argv[1];
+  else
+    fname = argv[3];
+  fd = open (fname, O_RDONLY);
+  if (fd < 0)
+    fail_errno ("couldn't open", fname);
+
+  elf = elf_begin (fd, ELF_C_READ, NULL);
+  if (elf == NULL)
+    fail_elf ("couldn't open ELF file for reading", fname);
+
+  GElf_Ehdr ehdr;
+  if (gelf_getehdr (elf, &ehdr) == NULL)
+    fail_elf ("Couldn't get ehdr", fname);
+
+  /* Get the section header string table.  */
+  size_t shdrstrndx;
+  if (elf_getshdrstrndx (elf, &shdrstrndx) != 0)
+    fail_elf ("couldn't get section header string table index", fname);
+
+  Elf_Scn *shdrstrscn = elf_getscn (elf, shdrstrndx);
+  GElf_Shdr shdrstrshdr_mem;
+  GElf_Shdr *shdrstrshdr = gelf_getshdr (shdrstrscn, &shdrstrshdr_mem);
+  if (shdrstrshdr == NULL)
+    fail_elf ("couldn't get section header string table section", fname);
+
+  if ((shdrstrshdr->sh_flags & SHF_ALLOC) != 0)
+    fail ("section header string table is an allocated section", fname);
+
+  /* Get the symtab section.  */
+  size_t symtabndx = 0;
+  Elf_Scn *symtabscn = NULL;
+  GElf_Shdr symtabshdr_mem;
+  GElf_Shdr *symtabshdr = NULL;
+  while ((symtabscn = elf_nextscn (elf, symtabscn)) != NULL)
+    {
+      symtabshdr = gelf_getshdr (symtabscn, &symtabshdr_mem);
+      if (symtabshdr == NULL)
+	fail_elf ("couldn't get shdr", fname);
+
+      if (symtabshdr->sh_type == SHT_SYMTAB)
+	{
+	  /* Just pick the first, we don't expect more than one. */
+	  symtabndx = elf_ndxscn (symtabscn);
+	  break;
+	}
+    }
+
+  if (symtabshdr == NULL)
+    fail ("No symtab found", fname);
+
+  if ((symtabshdr->sh_flags & SHF_ALLOC) != 0)
+    fail ("symtab is an allocated section", fname);
+
+  /* Get the strtab of the symtab.  */
+  size_t strtabndx = symtabshdr->sh_link;
+  Elf_Scn *strtabscn = elf_getscn (elf, strtabndx);
+  GElf_Shdr strtabshdr_mem;
+  GElf_Shdr *strtabshdr = gelf_getshdr (strtabscn, &strtabshdr_mem);
+  if (strtabshdr == NULL)
+    fail_elf ("Couldn't get strtab section", fname);
+
+  if (shdrstrndx == strtabndx)
+    {
+      error (0, 0, "%s: Nothing to do, shstrtab == strtab", fname);
+      release ();
+      return 0;
+    }
+
+  if ((strtabshdr->sh_flags & SHF_ALLOC) != 0)
+    fail ("strtab is an allocated section", fname);
+
+  size_t phnum;
+  if (elf_getphdrnum (elf, &phnum) != 0)
+    fail_elf ("Couldn't get number of phdrs", fname);
+
+  /* If there are phdrs we want to maintain the layout of the
+     allocated sections in the file.  */
+  bool layout = phnum != 0;
+
+  /* Create a new merged strings table that starts with the empty string.  */
+  strings = dwelf_strtab_init (true);
+  if (strings == NULL)
+    fail ("No memory to create merged string table", NULL);
+
+  /* Add the strings from all the sections.  */
+  size_t shdrnum;
+  if (elf_getshdrnum (elf, &shdrnum) != 0)
+    fail_elf ("Couldn't get number of sections", fname);
+  scnstrents = malloc (shdrnum * sizeof (Dwelf_Strent *));
+  if (scnstrents == NULL)
+    fail ("couldn't allocate memory for section strings", NULL);
+
+  /* While going through all sections keep track of last allocated
+     offset if needed to keep the layout.  We'll put any unallocated
+     sections behind those (strtab is unallocated and will change
+     size).  */
+  GElf_Off last_offset = 0;
+  if (layout)
+    last_offset = (ehdr.e_phoff
+		   + gelf_fsize (elf, ELF_T_PHDR, phnum, EV_CURRENT));
+  Elf_Scn *scn = NULL;
+  while ((scn = elf_nextscn (elf, scn)) != NULL)
+    {
+      size_t scnnum = elf_ndxscn (scn);
+      GElf_Shdr shdr_mem;
+      GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
+      if (shdr == NULL)
+	fail_elf_idx ("couldn't get shdr", fname, scnnum);
+      /* Don't add the .shstrtab section itself, we'll not use it.  */
+      if (shdr->sh_name != 0 && scnnum != shdrstrndx)
+	{
+	  const char *sname = elf_strptr (elf, shdrstrndx, shdr->sh_name);
+	  if (sname == NULL)
+	    fail_elf_idx ("couldn't get section name", fname, scnnum);
+	  if ((scnstrents[scnnum] = dwelf_strtab_add (strings, sname)) == NULL)
+	    fail ("No memory to add to merged string table", NULL);
+	}
+
+      if (layout)
+	if ((shdr->sh_flags & SHF_ALLOC) != 0)
+	  {
+	    GElf_Off off = shdr->sh_offset + (shdr->sh_type != SHT_NOBITS
+					      ? shdr->sh_size : 0);
+	    if (last_offset < off)
+	      last_offset = off;
+	  }
+    }
+
+  /* Add the strings from all the symbols.  */
+  size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT);
+  Elf_Data *symd = elf_getdata (symtabscn, NULL);
+  if (symd == NULL)
+    fail_elf ("couldn't get symtab data", fname);
+  size_t symsnum = symd->d_size / elsize;
+  symstrents = malloc (symsnum * sizeof (Dwelf_Strent *));
+  if (symstrents == NULL)
+    fail_errno ("Couldn't allocate memory for symbol strings", NULL);
+  for (size_t i = 0; i < symsnum; i++)
+    {
+      GElf_Sym sym_mem;
+      GElf_Sym *sym = gelf_getsym (symd, i, &sym_mem);
+      if (sym == NULL)
+	fail_elf_idx ("Couldn't get symbol", fname, i);
+      if (sym->st_name != 0)
+	{
+	  const char *sname = elf_strptr (elf, strtabndx, sym->st_name);
+	  if (sname == NULL)
+	    fail_elf_idx ("Couldn't get symbol name", fname, i);
+	  if ((symstrents[i] = dwelf_strtab_add (strings, sname)) == NULL)
+	    fail_idx ("No memory to add to merged string table symbol",
+		      fname, i);
+	}
+    }
+
+  /* We got all strings, build the new string table and store it as
+     new strtab.  */
+  dwelf_strtab_finalize (strings, &newstrtabdata);
+
+  /* We share at least the empty string so the result is at least 1
+     byte smaller.  */
+  if (newstrtabdata.d_size >= shdrstrshdr->sh_size + strtabshdr->sh_size)
+    fail ("Impossible, merged string table is larger", fname);
+
+  /* section index mapping and sanity checking.  */
+  size_t newsecndx (size_t secndx, const char *what, size_t widx,
+		    const char *member, size_t midx)
+  {
+    if (unlikely (secndx == 0 || secndx == shdrstrndx || secndx >= shdrnum))
+      {
+	/* Don't use fail... too specialized messages.  Call release
+	   outselves and then error.  Ignores midx if widx is
+	   zero.  */
+	release ();
+	if (widx == 0)
+	  error (1, 0, "%s: bad section index %zd in %s for %s",
+		 fname, secndx, what, member);
+	else if (midx == 0)
+	  error (1, 0, "%s: bad section index %zd in %s %zd for %s",
+		 fname, secndx, what, widx, member);
+	else
+	  error (1, 0, "%s: bad section index %zd in %s %zd for %s %zd",
+		 fname, secndx, what, widx, member, midx);
+      }
+
+    return secndx < shdrstrndx ? secndx : secndx - 1;
+  }
+
+  struct stat st;
+  if (fstat (fd, &st) != 0)
+    fail_errno("Couldn't fstat", fname);
+
+  /* Create a new (temporary) ELF file for the result.  */
+  if (replace)
+    {
+      size_t fname_len = strlen (fname);
+      fnew = malloc (fname_len + sizeof (".XXXXXX"));
+      if (fnew == NULL)
+	fail_errno ("couldn't allocate memory for new file name", NULL);
+      strcpy (mempcpy (fnew, fname, fname_len), ".XXXXXX");
+
+      fdnew = mkstemp (fnew);
+    }
+  else
+    {
+      fnew = argv[2];
+      fdnew = open (fnew, O_WRONLY | O_CREAT, st.st_mode & ALLPERMS);
+    }
+
+  if (fdnew < 0)
+    fail_errno ("couldn't create output file", fnew);
+
+  elfnew = elf_begin (fdnew, ELF_C_WRITE, NULL);
+  if (elfnew == NULL)
+    fail_elf ("couldn't open new ELF for writing", fnew);
+
+  /* Create the new ELF header and copy over all the data.  */
+  if (gelf_newehdr (elfnew, gelf_getclass (elf)) == 0)
+    fail_elf ("Couldn't create new ehdr", fnew);
+  GElf_Ehdr newehdr;
+  if (gelf_getehdr (elfnew, &newehdr) == NULL)
+    fail_elf ("Couldn't get ehdr", fnew);
+
+  newehdr.e_ident[EI_DATA] = ehdr.e_ident[EI_DATA];
+  newehdr.e_type = ehdr.e_type;
+  newehdr.e_machine = ehdr.e_machine;
+  newehdr.e_version = ehdr.e_version;
+  newehdr.e_entry = ehdr.e_entry;
+  newehdr.e_flags = ehdr.e_flags;
+
+  /* The new file uses the new strtab as shstrtab.  */
+  size_t newstrtabndx = newsecndx (strtabndx, "ehdr", 0, "e_shstrndx", 0);
+  if (newstrtabndx < SHN_LORESERVE)
+    newehdr.e_shstrndx = newstrtabndx;
+  else
+    {
+      Elf_Scn *zscn = elf_getscn (elfnew, 0);
+      GElf_Shdr zshdr_mem;
+      GElf_Shdr *zshdr = gelf_getshdr (zscn, &zshdr_mem);
+      if (zshdr == NULL)
+	fail_elf ("Couldn't get section zero", fnew);
+      zshdr->sh_link = strtabndx;
+      if (gelf_update_shdr (zscn, zshdr) == 0)
+	fail_elf ("Couldn't update section zero", fnew);
+      newehdr.e_shstrndx = SHN_XINDEX;
+    }
+
+  if (gelf_update_ehdr (elfnew, &newehdr) == 0)
+    fail ("Couldn't update ehdr", fnew);
+
+  /* Copy the program headers if any.  */
+  if (phnum != 0)
+    {
+      if (gelf_newphdr (elfnew, phnum) == 0)
+	fail_elf ("Couldn't create phdrs", fnew);
+
+      for (size_t cnt = 0; cnt < phnum; ++cnt)
+	{
+	  GElf_Phdr phdr_mem;
+	  GElf_Phdr *phdr = gelf_getphdr (elf, cnt, &phdr_mem);
+	  if (phdr == NULL)
+	    fail_elf_idx ("Couldn't get phdr", fname, cnt);
+	  if (gelf_update_phdr (elfnew, cnt, phdr) == 0)
+	    fail_elf_idx ("Couldn't create phdr", fnew, cnt);
+	}
+    }
+
+  newshnums = shdrnum - 1;
+  newscnbufs = calloc (sizeof (void *), newshnums);
+  if (newscnbufs == NULL)
+    fail_errno ("Couldn't allocate memory for new section buffers", NULL);
+
+  /* Copy the sections, except the shstrtab, fill the strtab with the
+     combined strings and adjust section references.  */
+  while ((scn = elf_nextscn (elf, scn)) != NULL)
+    {
+      size_t ndx = elf_ndxscn (scn);
+
+      GElf_Shdr shdr_mem;
+      GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
+      if (shdr == NULL)
+	fail_elf_idx ("Couldn't get shdr", fname, ndx);
+
+      /* Section zero is always created.  Skip the shtrtab.  */
+      if (ndx == 0 || ndx == shdrstrndx)
+	continue;
+
+      Elf_Scn *newscn = elf_newscn (elfnew);
+      if (newscn == NULL)
+	fail_elf_idx ("couldn't create new section", fnew, ndx);
+
+      GElf_Shdr newshdr;
+      newshdr.sh_name = (shdr->sh_name != 0
+			 ? dwelf_strent_off (scnstrents[ndx]) : 0);
+      newshdr.sh_type = shdr->sh_type;
+      newshdr.sh_flags = shdr->sh_flags;
+      newshdr.sh_addr = shdr->sh_addr;
+      newshdr.sh_size = shdr->sh_size;
+      if (shdr->sh_link != 0)
+	newshdr.sh_link = newsecndx (shdr->sh_link, "shdr", ndx, "sh_link", 0);
+      else
+	newshdr.sh_link = 0;
+      if (SH_INFO_LINK_P (shdr) && shdr->sh_info != 0)
+	newshdr.sh_info = newsecndx (shdr->sh_info, "shdr", ndx, "sh_info", 0);
+      else
+	newshdr.sh_info = shdr->sh_info;
+      newshdr.sh_entsize = shdr->sh_entsize;
+
+      /* Some sections need a new data buffer because they need to
+	 manipulate the original data.  Allocate and check here, so we
+	 have a list of all data buffers we might need to release when
+	 done.  */
+      void new_data_buf (Elf_Data *d)
+      {
+	size_t s = d->d_size;
+	if (s == 0)
+	  fail_idx ("Expected data in section", fname, ndx);
+	void *b = malloc (d->d_size);
+	if (b == NULL)
+	  fail_idx ("Couldn't allocated buffer for section", NULL, ndx);
+	newscnbufs[newsecndx (ndx, "section", ndx, "d_buf", 0)] = d->d_buf = b;
+      }
+
+      Elf_Data *newdata = elf_newdata (newscn);
+      if (newdata == NULL)
+	fail_elf_idx ("Couldn't create new data for section", fnew, ndx);
+      if (ndx == strtabndx)
+	*newdata = newstrtabdata;
+      else
+	{
+	  /* The symtab, dynsym, group and symtab_shndx sections
+	     contain section indexes. Symbol tables (symtab and
+	     dynsym) contain indexes to strings. Update both if
+	     necessary.  */
+	  Elf_Data *data = elf_getdata (scn, NULL);
+	  if (data == NULL)
+	    fail_elf_idx ("Couldn't get data from section", fname, ndx);
+	  *newdata = *data;
+	  switch (shdr->sh_type)
+	    {
+	    case SHT_SYMTAB:
+	    case SHT_DYNSYM:
+	      {
+		/* We need to update the section numbers of the
+		   symbols and if this symbol table uses the strtab
+		   section also the name indexes.  */
+		const bool update_name = shdr->sh_link == strtabndx;
+		if (update_name && ndx != symtabndx)
+		  fail ("Only one symbol table using strtab expected", fname);
+		new_data_buf (newdata);
+		size_t syms = (data->d_size
+			       / gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT));
+		for (size_t i = 0; i < syms; i++)
+		  {
+		    GElf_Sym sym;
+		    if (gelf_getsym (data, i, &sym) == NULL)
+		      fail_elf_idx ("Couldn't get symbol", fname, i);
+
+		    if (GELF_ST_TYPE (sym.st_info) == STT_SECTION
+			&& sym.st_shndx == shdrstrndx)
+		      fprintf (stderr, "WARNING:"
+			       " symbol table [%zd] contains section symbol %zd"
+			       " for old shdrstrndx %zd\n", ndx, i, shdrstrndx);
+		    else if (sym.st_shndx != SHN_UNDEF
+			     && sym.st_shndx < SHN_LORESERVE)
+		      sym.st_shndx = newsecndx (sym.st_shndx, "section", ndx,
+						"symbol", i);
+		    if (update_name && sym.st_name != 0)
+		      sym.st_name = dwelf_strent_off (symstrents[i]);
+
+		    /* We explicitly don't update the SHNDX table at
+		       the same time, we do that below.  */
+		    if (gelf_update_sym (newdata, i, &sym) == 0)
+		      fail_elf_idx ("Couldn't update symbol", fnew, i);
+		  }
+	      }
+	      break;
+
+	    case SHT_GROUP:
+	      {
+		new_data_buf (newdata);
+		/* A section group contains Elf32_Words. The first
+		   word is a falg value, the rest of the words are
+		   indexes of the sections belonging to the group.  */
+		Elf32_Word *group = (Elf32_Word *) data->d_buf;
+		Elf32_Word *newgroup = (Elf32_Word *) newdata->d_buf;
+		size_t words = data->d_size / sizeof (Elf32_Word);
+		if (words == 0)
+		  fail_idx ("Not enough data in group section", fname, ndx);
+		newgroup[0] = group[0];
+		for (size_t i = 1; i < words; i++)
+		  newgroup[i] = newsecndx (group[i], "section", ndx,
+					   "group", i);
+	      }
+	      break;
+
+	    case SHT_SYMTAB_SHNDX:
+	      {
+		new_data_buf (newdata);
+		/* A SHNDX just contains an array of section indexes
+		   for the corresponding symbol table.  The entry is
+		   SHN_UNDEF unless the corresponding symbol is
+		   SHN_XINDEX.  */
+		Elf32_Word *shndx = (Elf32_Word *) data->d_buf;
+		Elf32_Word *newshndx = (Elf32_Word *) newdata->d_buf;
+		size_t words = data->d_size / sizeof (Elf32_Word);
+		for (size_t i = 0; i < words; i++)
+		  if (shndx[i] == SHN_UNDEF)
+		    newshndx[i] = SHN_UNDEF;
+		  else
+		    newshndx[i] = newsecndx (shndx[i], "section", ndx,
+					     "shndx", i);
+	      }
+	      break;
+
+	    case SHT_DYNAMIC:
+	      FALLTHROUGH;
+	      /* There are string indexes in here, but
+		 they (should) point to a allocated string table,
+		 which we don't alter.  */
+	    default:
+	      /* Nothing to do.  Section data doesn't contain section
+		 or strtab indexes.  */
+	      break;
+	    }
+	}
+
+      /* When we are responsible for the layout explicitly set
+	 sh_addralign, sh_size and sh_offset.  Otherwise libelf will
+	 calculate those from the Elf_Data.  */
+      if (layout)
+	{
+	  /* We have just one Elf_Data.  */
+	  newshdr.sh_size = newdata->d_size;
+	  newshdr.sh_addralign = newdata->d_align;
+
+	  /* Keep the offset of allocated sections so they are at the
+	     same place in the file. Add unallocated ones after the
+	     allocated ones.  */
+	  if ((shdr->sh_flags & SHF_ALLOC) != 0)
+	    newshdr.sh_offset = shdr->sh_offset;
+	  else
+	    {
+	      /* Zero means one.  No alignment constraints.  */
+	      size_t addralign = newshdr.sh_addralign ?: 1;
+	      last_offset = (last_offset + addralign - 1) & ~(addralign - 1);
+	      newshdr.sh_offset = last_offset;
+	      if (newshdr.sh_type != SHT_NOBITS)
+		last_offset += newshdr.sh_size;
+	    }
+	}
+      else
+	{
+	  newshdr.sh_addralign = 0;
+	  newshdr.sh_size = 0;
+	  newshdr.sh_offset = 0;
+	}
+
+      if (gelf_update_shdr (newscn, &newshdr) == 0)
+	fail_elf_idx ("Couldn't update section header", fnew, ndx);
+    }
+
+  /* If we have phdrs we want elf_update to layout the SHF_ALLOC
+     sections precisely as in the original file.  In that case we are
+     also responsible for setting phoff and shoff */
+  if (layout)
+    {
+      /* Position the shdrs after the last (unallocated) section.  */
+      if (gelf_getehdr (elfnew, &newehdr) == NULL)
+	fail_elf ("Couldn't get ehdr", fnew);
+      const size_t offsize = gelf_fsize (elf, ELF_T_OFF, 1, EV_CURRENT);
+      newehdr.e_shoff = ((last_offset + offsize - 1)
+			 & ~((GElf_Off) (offsize - 1)));
+
+      /* The phdrs go in the same place as in the original file.
+	 Normally right after the ELF header.  */
+      newehdr.e_phoff = ehdr.e_phoff;
+
+      if (gelf_update_ehdr (elfnew, &newehdr) == 0)
+	fail_elf ("Couldn't update ehdr", fnew);
+
+      elf_flagelf (elfnew, ELF_C_SET, ELF_F_LAYOUT);
+    }
+
+  if (elf_update (elfnew, ELF_C_WRITE) == -1)
+    fail_elf ("Couldn't write ELF", fnew);
+
+  elf_end (elfnew);
+  elfnew = NULL;
+
+  /* Try to match mode and owner.group of the original file.  */
+  if (fchmod (fdnew, st.st_mode & ALLPERMS) != 0)
+    error (0, errno, "Couldn't fchmod %s", fnew);
+  if (fchown (fdnew, st.st_uid, st.st_gid) != 0)
+    error (0, errno, "Couldn't fchown %s", fnew);
+
+  /* Finally replace the old file with the new merged strings file.  */
+  if (replace)
+    if (rename (fnew, fname) != 0)
+      fail_errno ("rename", fnew);
+
+  /* We are finally done with the new file, don't unlink it now.  */
+  close (fdnew);
+  if (replace)
+    free (fnew);
+  fnew = NULL;
+  fdnew = -1;
+
+  release ();
+  return 0;
+}