/* Combine stripped files with separate symbols and debug information.

   Copyright (C) 2007-2012, 2014, 2015 Red Hat, Inc.

   This file is part of elfutils.

   Written by Roland McGrath <roland@redhat.com>, 2007.

   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/>.  */

/* TODO:

  * SHX_XINDEX

  * prelink vs .debug_* linked addresses

 */

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include <argp.h>

#include <assert.h>

#include <errno.h>

#include <fcntl.h>

#include <fnmatch.h>

#include <libintl.h>

#include <locale.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdio_ext.h>

#include <inttypes.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/stat.h>

#include <gelf.h>

#include <libebl.h>

#include <libdwfl.h>

#include "system.h"

#include "libdwelf.h"

#include "libeu.h"

#include "printversion.h"

#ifndef _

# define _(str) gettext (str)

#endif

/* Name and version of program.  */

ARGP_PROGRAM_VERSION_HOOK_DEF = print_version;

/* Bug report address.  */

ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT;

/* Definitions of arguments for argp functions.  */

static const struct argp_option options[] =

{

  /* Group 2 will follow group 1 from dwfl_standard_argp.  */

  { "match-file-names", 'f', NULL, 0,

    N_("Match MODULE against file names, not module names"), 2 },

  { "ignore-missing", 'i', NULL, 0, N_("Silently skip unfindable files"), 0 },

  { NULL, 0, NULL, 0, N_("Output options:"), 0 },

  { "output", 'o', "FILE", 0, N_("Place output into FILE"), 0 },

  { "output-directory", 'd', "DIRECTORY",

    0, N_("Create multiple output files under DIRECTORY"), 0 },

  { "module-names", 'm', NULL, 0, N_("Use module rather than file names"), 0 },

  { "all", 'a', NULL, 0,

    N_("Create output for modules that have no separate debug information"),

    0 },

  { "relocate", 'R', NULL, 0,

    N_("Apply relocations to section contents in ET_REL files"), 0 },

  { "list-only", 'n', NULL, 0,

    N_("Only list module and file names, build IDs"), 0 },

 { "force", 'F', NULL, 0,

    N_("Force combining files even if some ELF headers don't seem to match"),

   0 },

  { NULL, 0, NULL, 0, NULL, 0 }

};

struct arg_info

{

  const char *output_file;

  const char *output_dir;

  Dwfl *dwfl;

  char **args;

  bool list;

  bool all;

  bool ignore;

  bool modnames;

  bool match_files;

  bool relocate;

  bool force;

};

/* Handle program arguments.  */

static error_t

parse_opt (int key, char *arg, struct argp_state *state)

{

  struct arg_info *info = state->input;

  switch (key)

    {

    case ARGP_KEY_INIT:

      state->child_inputs[0] = &info->dwfl;

      break;

    case 'o':

      if (info->output_file != NULL)

	{

	  argp_error (state, _("-o option specified twice"));

	  return EINVAL;

	}

      info->output_file = arg;

      break;

    case 'd':

      if (info->output_dir != NULL)

	{

	  argp_error (state, _("-d option specified twice"));

	  return EINVAL;

	}

      info->output_dir = arg;

      break;

    case 'm':

      info->modnames = true;

      break;

    case 'f':

      info->match_files = true;

      break;

    case 'a':

      info->all = true;

      break;

    case 'i':

      info->ignore = true;

      break;

    case 'n':

      info->list = true;

      break;

    case 'R':

      info->relocate = true;

      break;

    case 'F':

      info->force = true;

      break;

    case ARGP_KEY_ARGS:

    case ARGP_KEY_NO_ARGS:

      /* We "consume" all the arguments here.  */

      info->args = &state->argv[state->next];

      if (info->output_file != NULL && info->output_dir != NULL)

	{

	  argp_error (state, _("only one of -o or -d allowed"));

	  return EINVAL;

	}

      if (info->list && (info->dwfl == NULL

			 || info->output_dir != NULL

			 || info->output_file != NULL))

	{

	  argp_error (state,

		      _("-n cannot be used with explicit files or -o or -d"));

	  return EINVAL;

	}

      if (info->output_dir != NULL)

	{

	  struct stat st;

	  error_t fail = 0;

	  if (stat (info->output_dir, &st) < 0)

	    fail = errno;

	  else if (!S_ISDIR (st.st_mode))

	    fail = ENOTDIR;

	  if (fail)

	    {

	      argp_failure (state, EXIT_FAILURE, fail,

			    _("output directory '%s'"), info->output_dir);

	      return fail;

	    }

	}

      if (info->dwfl == NULL)

	{

	  if (state->next + 2 != state->argc)

	    {

	      argp_error (state, _("exactly two file arguments are required"));

	      return EINVAL;

	    }

	  if (info->ignore || info->all || info->modnames || info->relocate)

	    {

	      argp_error (state, _("\

-m, -a, -R, and -i options not allowed with explicit files"));

	      return EINVAL;

	    }

	  /* Bail out immediately to prevent dwfl_standard_argp's parser

	     from defaulting to "-e a.out".  */

	  return ENOSYS;

	}

      else if (info->output_file == NULL && info->output_dir == NULL

	       && !info->list)

	{

	  argp_error (state,

		      _("-o or -d is required when using implicit files"));

	  return EINVAL;

	}

      break;

    default:

      return ARGP_ERR_UNKNOWN;

    }

  return 0;

}

#define ELF_CHECK(call, msg)						      \

  do									      \

    {									      \

      if (unlikely (!(call)))						      \

	error (EXIT_FAILURE, 0, msg, elf_errmsg (-1));			      \

    } while (0)

/* Copy INELF to newly-created OUTELF, exit via error for any problems.  */

static void

copy_elf (Elf *outelf, Elf *inelf)

{

  ELF_CHECK (gelf_newehdr (outelf, gelf_getclass (inelf)),

	     _("cannot create ELF header: %s"));

  size_t shstrndx;

  ELF_CHECK (elf_getshdrstrndx (inelf, &shstrndx) == 0,

	     _("cannot get shdrstrndx:%s"));

  GElf_Ehdr ehdr_mem;

  GElf_Ehdr *ehdr = gelf_getehdr (inelf, &ehdr_mem);

  ELF_CHECK (ehdr != NULL, _("cannot get ELF header: %s"));

  if (shstrndx < SHN_LORESERVE)

    ehdr->e_shstrndx = shstrndx;

  else

    {

      ehdr->e_shstrndx = SHN_XINDEX;

      Elf_Scn *scn0 = elf_getscn (outelf, 0);

      GElf_Shdr shdr0_mem;

      GElf_Shdr *shdr0 = gelf_getshdr (scn0, &shdr0_mem);

      ELF_CHECK (shdr0 != NULL,

		 _("cannot get new zero section: %s"));

      shdr0->sh_link = shstrndx;

      ELF_CHECK (gelf_update_shdr (scn0, shdr0),

		 _("cannot update new zero section: %s"));

    }

  ELF_CHECK (gelf_update_ehdr (outelf, ehdr),

	     _("cannot copy ELF header: %s"));

  size_t phnum;

  ELF_CHECK (elf_getphdrnum (inelf, &phnum) == 0,

	     _("cannot get number of program headers: %s"));

  if (phnum > 0)

    {

      ELF_CHECK (gelf_newphdr (outelf, phnum),

		 _("cannot create program headers: %s"));

      GElf_Phdr phdr_mem;

      for (size_t i = 0; i < phnum; ++i)

	ELF_CHECK (gelf_update_phdr (outelf, i,

				     gelf_getphdr (inelf, i, &phdr_mem)),

		   _("cannot copy program header: %s"));

    }

  Elf_Scn *scn = NULL;

  while ((scn = elf_nextscn (inelf, scn)) != NULL)

    {

      Elf_Scn *newscn = elf_newscn (outelf);

      GElf_Shdr shdr_mem;

      ELF_CHECK (gelf_update_shdr (newscn, gelf_getshdr (scn, &shdr_mem)),

		 _("cannot copy section header: %s"));

      Elf_Data *data = elf_getdata (scn, NULL);

      ELF_CHECK (data != NULL, _("cannot get section data: %s"));

      Elf_Data *newdata = elf_newdata (newscn);

      ELF_CHECK (newdata != NULL, _("cannot copy section data: %s"));

      *newdata = *data;

      elf_flagdata (newdata, ELF_C_SET, ELF_F_DIRTY);

    }

}

/* Create directories containing PATH.  */

static void

make_directories (const char *path)

{

  const char *lastslash = strrchr (path, '/');

  if (lastslash == NULL)

    return;

  while (lastslash > path && lastslash[-1] == '/')

    --lastslash;

  if (lastslash == path)

    return;

  char *dir = strndup (path, lastslash - path);

  if (dir == NULL)

    error(EXIT_FAILURE, errno, _("memory exhausted"));

  while (mkdir (dir, 0777) < 0 && errno != EEXIST)

    {

      if (errno == ENOENT)

        make_directories (dir);

      else

        error (EXIT_FAILURE, errno, _("cannot create directory '%s'"), dir);

    }

  free (dir);

}

/* Keep track of new section data we are creating, so we can free it

   when done.  */

struct data_list

{

  void *data;

  struct data_list *next;

};

struct data_list *new_data_list;

static void

record_new_data (void *data)

{

  struct data_list *next = new_data_list;

  new_data_list = xmalloc (sizeof (struct data_list));

  new_data_list->data = data;

  new_data_list->next = next;

}

static void

free_new_data (void)

{

  struct data_list *list = new_data_list;

  while (list != NULL)

    {

      struct data_list *next = list->next;

      free (list->data);

      free (list);

      list = next;

    }

  new_data_list = NULL;

}

/* The binutils linker leaves gratuitous section symbols in .symtab

   that strip has to remove.  Older linkers likewise include a

   symbol for every section, even unallocated ones, in .dynsym.

   Because of this, the related sections can shrink in the stripped

   file from their original size.  Older versions of strip do not

   adjust the sh_size field in the debuginfo file's SHT_NOBITS

   version of the section header, so it can appear larger.  */

static bool

section_can_shrink (const GElf_Shdr *shdr)

{

  switch (shdr->sh_type)

    {

    case SHT_SYMTAB:

    case SHT_DYNSYM:

    case SHT_HASH:

    case SHT_GNU_versym:

      return true;

    }

  return false;

}

/* See if this symbol table has a leading section symbol for every single

   section, in order.  The binutils linker produces this.  While we're here,

   update each section symbol's st_value.  */

static size_t

symtab_count_leading_section_symbols (Elf *elf, Elf_Scn *scn, size_t shnum,

				      Elf_Data *newsymdata)

{

  Elf_Data *data = elf_getdata (scn, NULL);

  Elf_Data *shndxdata = NULL;	/* XXX */

  for (size_t i = 1; i < shnum; ++i)

    {

      GElf_Sym sym_mem;

      GElf_Word shndx = SHN_UNDEF;

      GElf_Sym *sym = gelf_getsymshndx (data, shndxdata, i, &sym_mem, &shndx);

      ELF_CHECK (sym != NULL, _("cannot get symbol table entry: %s"));

      GElf_Shdr shdr_mem;

      GElf_Shdr *shdr = gelf_getshdr (elf_getscn (elf, i), &shdr_mem);

      ELF_CHECK (shdr != NULL, _("cannot get section header: %s"));

      if (sym->st_shndx != SHN_XINDEX)

	shndx = sym->st_shndx;

      if (shndx != i || GELF_ST_TYPE (sym->st_info) != STT_SECTION)

	return i;

      sym->st_value = shdr->sh_addr;

      if (sym->st_shndx != SHN_XINDEX)

	shndx = SHN_UNDEF;

      ELF_CHECK (gelf_update_symshndx (newsymdata, shndxdata, i, sym, shndx),

		 _("cannot update symbol table: %s"));

    }

  return shnum;

}

static void

update_shdr (Elf_Scn *outscn, GElf_Shdr *newshdr)

{

  ELF_CHECK (gelf_update_shdr (outscn, newshdr),

	     _("cannot update section header: %s"));

}

/* We expanded the output section, so update its header.  */

static void

update_sh_size (Elf_Scn *outscn, const Elf_Data *data)

{

  GElf_Shdr shdr_mem;

  GElf_Shdr *newshdr = gelf_getshdr (outscn, &shdr_mem);

  ELF_CHECK (newshdr != NULL, _("cannot get section header: %s"));

  newshdr->sh_size = data->d_size;

  update_shdr (outscn, newshdr);

}

/* Update relocation sections using the symbol table.  */

static void

adjust_relocs (Elf_Scn *outscn, Elf_Scn *inscn, const GElf_Shdr *shdr,

	       size_t map[], size_t map_size, const GElf_Shdr *symshdr)

{

  Elf_Data *data = elf_getdata (outscn, NULL);

  inline void adjust_reloc (GElf_Xword *info)

    {

      size_t ndx = GELF_R_SYM (*info);

      if (ndx != STN_UNDEF)

	{

	  if (ndx > map_size)

	    error (EXIT_FAILURE, 0, "bad symbol ndx section");

	  *info = GELF_R_INFO (map[ndx - 1], GELF_R_TYPE (*info));

	}

    }

  switch (shdr->sh_type)

    {

    case SHT_REL:

      if (shdr->sh_entsize == 0)

	error (EXIT_FAILURE, 0, "REL section cannot have zero sh_entsize");

      for (size_t i = 0; i < shdr->sh_size / shdr->sh_entsize; ++i)

	{

	  GElf_Rel rel_mem;

	  GElf_Rel *rel = gelf_getrel (data, i, &rel_mem);

	  adjust_reloc (&rel->r_info);

	  ELF_CHECK (gelf_update_rel (data, i, rel),

		     _("cannot update relocation: %s"));

	}

      break;

    case SHT_RELA:

      if (shdr->sh_entsize == 0)

	error (EXIT_FAILURE, 0, "RELA section cannot have zero sh_entsize");

      for (size_t i = 0; i < shdr->sh_size / shdr->sh_entsize; ++i)

	{

	  GElf_Rela rela_mem;

	  GElf_Rela *rela = gelf_getrela (data, i, &rela_mem);

	  adjust_reloc (&rela->r_info);

	  ELF_CHECK (gelf_update_rela (data, i, rela),

		     _("cannot update relocation: %s"));

	}

      break;

    case SHT_GROUP:

      {

	GElf_Shdr shdr_mem;

	GElf_Shdr *newshdr = gelf_getshdr (outscn, &shdr_mem);

	ELF_CHECK (newshdr != NULL, _("cannot get section header: %s"));

	if (newshdr->sh_info != STN_UNDEF)

	  {

	    newshdr->sh_info = map[newshdr->sh_info - 1];

	    update_shdr (outscn, newshdr);

	  }

	break;

      }

    case SHT_HASH:

      /* We must expand the table and rejigger its contents.  */

      {

	if (shdr->sh_entsize == 0)

	  error (EXIT_FAILURE, 0, "HASH section cannot have zero sh_entsize");

	if (symshdr->sh_entsize == 0)

	  error (EXIT_FAILURE, 0, "Symbol table cannot have zero sh_entsize");

	const size_t nsym = symshdr->sh_size / symshdr->sh_entsize;

	const size_t onent = shdr->sh_size / shdr->sh_entsize;

	if (data->d_size != shdr->sh_size)

	  error (EXIT_FAILURE, 0, "HASH section has inconsistent size");

#define CONVERT_HASH(Hash_Word)						      \

	{								      \

	  const Hash_Word *const old_hash = data->d_buf;		      \

	  const size_t nbucket = old_hash[0];				      \

	  const size_t nchain = old_hash[1];				      \

	  const Hash_Word *const old_bucket = &old_hash[2];		      \

	  const Hash_Word *const old_chain = &old_bucket[nbucket];	      \

	  if (onent != 2 + nbucket + nchain)				      \

	    error (EXIT_FAILURE, 0, "HASH section has inconsistent entsize"); \

									      \

	  const size_t nent = 2 + nbucket + nsym;			      \

	  Hash_Word *const new_hash = xcalloc (nent, sizeof new_hash[0]);     \

	  Hash_Word *const new_bucket = &new_hash[2];			      \

	  Hash_Word *const new_chain = &new_bucket[nbucket];		      \

									      \

	  new_hash[0] = nbucket;					      \

	  new_hash[1] = nsym;						      \

	  for (size_t i = 0; i < nbucket; ++i)				      \

	    if (old_bucket[i] != STN_UNDEF)				      \

	      new_bucket[i] = map[old_bucket[i] - 1];			      \

									      \

	  for (size_t i = 1; i < nchain; ++i)				      \

	    if (old_chain[i] != STN_UNDEF)				      \

	      new_chain[map[i - 1]] = map[old_chain[i] - 1];		      \

									      \

	  record_new_data (new_hash);					\

	  data->d_buf = new_hash;					      \

	  data->d_size = nent * sizeof new_hash[0];			      \

	}

	switch (shdr->sh_entsize)

	  {

	  case 4:

	    CONVERT_HASH (Elf32_Word);

	    break;

	  case 8:

	    CONVERT_HASH (Elf64_Xword);

	    break;

	  default:

	    abort ();

	  }

	elf_flagdata (data, ELF_C_SET, ELF_F_DIRTY);

	update_sh_size (outscn, data);

#undef	CONVERT_HASH

      }

      break;

    case SHT_GNU_versym:

      /* We must expand the table and move its elements around.  */

      {

	if (shdr->sh_entsize == 0)

	  error (EXIT_FAILURE, 0,

		 "GNU_versym section cannot have zero sh_entsize");

	if (symshdr->sh_entsize == 0)

	  error (EXIT_FAILURE, 0, "Symbol table cannot have zero sh_entsize");

	const size_t nent = symshdr->sh_size / symshdr->sh_entsize;

	const size_t onent = shdr->sh_size / shdr->sh_entsize;

	assert (nent >= onent);

	/* We don't bother using gelf_update_versym because there is

	   really no conversion to be done.  */

	assert (sizeof (Elf32_Versym) == sizeof (GElf_Versym));

	assert (sizeof (Elf64_Versym) == sizeof (GElf_Versym));

	GElf_Versym *versym = xcalloc (nent, sizeof versym[0]);

	for (size_t i = 1; i < onent; ++i)

	  {

	    GElf_Versym *v = gelf_getversym (data, i, &versym[map[i - 1]]);

	    ELF_CHECK (v != NULL, _("cannot get symbol version: %s"));

	  }

	record_new_data (versym);

	data->d_buf = versym;

	data->d_size = nent * sizeof versym[0];

	elf_flagdata (data, ELF_C_SET, ELF_F_DIRTY);

	update_sh_size (outscn, data);

      }

      break;

    default:

      error (EXIT_FAILURE, 0,

	     _("unexpected section type in [%zu] with sh_link to symtab"),

	     elf_ndxscn (inscn));

    }

}

/* Adjust all the relocation sections in the file.  */

static void

adjust_all_relocs (Elf *elf, Elf_Scn *symtab, const GElf_Shdr *symshdr,

		   size_t map[], size_t map_size)

{

  size_t new_sh_link = elf_ndxscn (symtab);

  Elf_Scn *scn = NULL;

  while ((scn = elf_nextscn (elf, scn)) != NULL)

    if (scn != symtab)

      {

	GElf_Shdr shdr_mem;

	GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);

	ELF_CHECK (shdr != NULL, _("cannot get section header: %s"));

	/* Don't redo SHT_GROUP, groups are in both the stripped and debug,

	   it will already have been done by adjust_relocs for the

	   stripped_symtab.  */

	if (shdr->sh_type != SHT_NOBITS && shdr->sh_type != SHT_GROUP

	    && shdr->sh_link == new_sh_link)

	  adjust_relocs (scn, scn, shdr, map, map_size, symshdr);

      }

}

/* The original file probably had section symbols for all of its

   sections, even the unallocated ones.  To match it as closely as

   possible, add in section symbols for the added sections.  */

static Elf_Data *

add_new_section_symbols (Elf_Scn *old_symscn, size_t old_shnum,

			 Elf *elf, bool rel, Elf_Scn *symscn, size_t shnum)

{

  const size_t added = shnum - old_shnum;

  GElf_Shdr shdr_mem;

  GElf_Shdr *shdr = gelf_getshdr (symscn, &shdr_mem);

  ELF_CHECK (shdr != NULL, _("cannot get section header: %s"));

  if (shdr->sh_entsize == 0)

    error (EXIT_FAILURE, 0, "Symbol table section cannot have zero sh_entsize");

  const size_t nsym = shdr->sh_size / shdr->sh_entsize;

  size_t symndx_map[nsym - 1];

  shdr->sh_info += added;

  shdr->sh_size += added * shdr->sh_entsize;

  update_shdr (symscn, shdr);

  Elf_Data *symdata = elf_getdata (symscn, NULL);

  Elf_Data *shndxdata = NULL;	/* XXX */

  symdata->d_size = shdr->sh_size;

  symdata->d_buf = xmalloc (symdata->d_size);

  record_new_data (symdata->d_buf);

  /* Copy the existing section symbols.  */

  Elf_Data *old_symdata = elf_getdata (old_symscn, NULL);

  for (size_t i = 0; i < old_shnum; ++i)

    {

      GElf_Sym sym_mem;

      GElf_Word shndx = SHN_UNDEF;

      GElf_Sym *sym = gelf_getsymshndx (old_symdata, shndxdata,

					i, &sym_mem, &shndx);

      ELF_CHECK (sym != NULL, _("cannot get symbol table entry: %s"));

      ELF_CHECK (gelf_update_symshndx (symdata, shndxdata, i,

				       sym, shndx),

		 _("cannot update symbol table: %s"));

      if (i > 0)

	symndx_map[i - 1] = i;

    }

  /* Add in the new section symbols.  */

  for (size_t i = old_shnum; i < shnum; ++i)

    {

      GElf_Shdr i_shdr_mem;

      GElf_Shdr *i_shdr = gelf_getshdr (elf_getscn (elf, i), &i_shdr_mem);

      ELF_CHECK (i_shdr != NULL, _("cannot get section header: %s"));

      GElf_Sym sym =

	{

	  .st_value = rel ? 0 : i_shdr->sh_addr,

	  .st_info = GELF_ST_INFO (STB_LOCAL, STT_SECTION),

	  .st_shndx = i < SHN_LORESERVE ? i : SHN_XINDEX

	};

      GElf_Word shndx = i < SHN_LORESERVE ? SHN_UNDEF : i;

      ELF_CHECK (gelf_update_symshndx (symdata, shndxdata, i,

				       &sym, shndx),

		 _("cannot update symbol table: %s"));

    }

  /* Now copy the rest of the existing symbols.  */

  for (size_t i = old_shnum; i < nsym; ++i)

    {

      GElf_Sym sym_mem;

      GElf_Word shndx = SHN_UNDEF;

      GElf_Sym *sym = gelf_getsymshndx (old_symdata, shndxdata,

					i, &sym_mem, &shndx);

      ELF_CHECK (sym != NULL, _("cannot get symbol table entry: %s"));

      ELF_CHECK (gelf_update_symshndx (symdata, shndxdata,

				       i + added, sym, shndx),

		 _("cannot update symbol table: %s"));

      symndx_map[i - 1] = i + added;

    }

  /* Adjust any relocations referring to the old symbol table.  */

  adjust_all_relocs (elf, symscn, shdr, symndx_map, nsym - 1);

  return symdata;

}

/* This has the side effect of updating STT_SECTION symbols' values,

   in case of prelink adjustments.  */

static Elf_Data *

check_symtab_section_symbols (Elf *elf, bool rel, Elf_Scn *scn,

			      size_t shnum, size_t shstrndx,

			      Elf_Scn *oscn, size_t oshnum, size_t oshstrndx,

			      size_t debuglink)

{

  size_t n = symtab_count_leading_section_symbols (elf, oscn, oshnum,

						   elf_getdata (scn, NULL));

  if (n == oshnum)

    return add_new_section_symbols (oscn, n, elf, rel, scn, shnum);

  if (n == oshstrndx || (n == debuglink && n == oshstrndx - 1))

    return add_new_section_symbols (oscn, n, elf, rel, scn, shstrndx);

  return NULL;

}

struct section

{

  Elf_Scn *scn;

  const char *name;

  const char *sig;

  Elf_Scn *outscn;

  Dwelf_Strent *strent;

  GElf_Shdr shdr;

};

static int

compare_alloc_sections (const struct section *s1, const struct section *s2,

			bool rel)

{

  if (!rel)

    {

      /* Sort by address.  */

      if (s1->shdr.sh_addr < s2->shdr.sh_addr)

	return -1;

      if (s1->shdr.sh_addr > s2->shdr.sh_addr)

	return 1;

    }

  /* At the same address, preserve original section order.  */

  return (ssize_t) elf_ndxscn (s1->scn) - (ssize_t) elf_ndxscn (s2->scn);

}

static int

compare_unalloc_sections (const GElf_Shdr *shdr1, const GElf_Shdr *shdr2,

			  const char *name1, const char *name2,

			  const char *sig1, const char *sig2)

{

  /* Sort by sh_flags as an arbitrary ordering.  */

  if (shdr1->sh_flags < shdr2->sh_flags)

    return -1;

  if (shdr1->sh_flags > shdr2->sh_flags)

    return 1;

  /* Sizes should be the same.  */

  if (shdr1->sh_size < shdr2->sh_size)

    return -1;

  if (shdr1->sh_size > shdr2->sh_size)

    return 1;

  /* Are they both SHT_GROUP sections? Then compare signatures.  */

  if (sig1 != NULL && sig2 != NULL)

    return strcmp (sig1, sig2);

  /* Sort by name as last resort.  */

  return strcmp (name1, name2);

}

static int

compare_sections (const void *a, const void *b, bool rel)

{

  const struct section *s1 = a;

  const struct section *s2 = b;

  /* Sort all non-allocated sections last.  */

  if ((s1->shdr.sh_flags ^ s2->shdr.sh_flags) & SHF_ALLOC)

    return (s1->shdr.sh_flags & SHF_ALLOC) ? -1 : 1;

  return ((s1->shdr.sh_flags & SHF_ALLOC)

	  ? compare_alloc_sections (s1, s2, rel)

	  : compare_unalloc_sections (&s1->shdr, &s2->shdr,

				      s1->name, s2->name,

				      s1->sig, s2->sig));

}

static int

compare_sections_rel (const void *a, const void *b)

{

  return compare_sections (a, b, true);

}

static int

compare_sections_nonrel (const void *a, const void *b)

{

  return compare_sections (a, b, false);

}

struct symbol

{

  size_t *map;

  union

  {

    const char *name;

    Dwelf_Strent *strent;

  };

  union

  {

    struct

    {

      GElf_Addr value;

      GElf_Xword size;

      GElf_Word shndx;

      union

      {

	struct

	{

	  uint8_t info;

	  uint8_t other;

	} info;

	int16_t compare;

      };

    };

    /* For a symbol discarded after first sort, this matches its better's

       map pointer.  */

    size_t *duplicate;

  };

};

/* Collect input symbols into our internal form.  */

static void

collect_symbols (Elf *outelf, bool rel, Elf_Scn *symscn, Elf_Scn *strscn,

		 const size_t nent, const GElf_Addr bias,

		 const size_t scnmap[], struct symbol *table, size_t *map,

		 struct section *split_bss)

{

  Elf_Data *symdata = elf_getdata (symscn, NULL);

  ELF_CHECK (symdata != NULL, _("cannot get symbol section data: %s"));

  Elf_Data *strdata = elf_getdata (strscn, NULL);

  ELF_CHECK (strdata != NULL, _("cannot get string section data: %s"));

  Elf_Data *shndxdata = NULL;	/* XXX */

  for (size_t i = 1; i < nent; ++i)

    {

      GElf_Sym sym_mem;

      GElf_Word shndx = SHN_UNDEF;

      GElf_Sym *sym = gelf_getsymshndx (symdata, shndxdata, i,

					&sym_mem, &shndx);

      ELF_CHECK (sym != NULL, _("cannot get symbol table entry: %s"));

      if (sym->st_shndx != SHN_XINDEX)

	shndx = sym->st_shndx;

      if (sym->st_name >= strdata->d_size

	  || memrchr (strdata->d_buf + sym->st_name, '\0',

		      strdata->d_size - sym->st_name) == NULL)

	error (EXIT_FAILURE, 0,

	       _("invalid string offset in symbol [%zu]"), i);

      struct symbol *s = &table[i - 1];

      s->map = &map[i - 1];

      s->name = strdata->d_buf + sym->st_name;

      s->value = sym->st_value + bias;

      s->size = sym->st_size;

      s->shndx = shndx;

      s->info.info = sym->st_info;

      s->info.other = sym->st_other;

      if (scnmap != NULL && shndx != SHN_UNDEF && shndx < SHN_LORESERVE)