/* Discard section not used at runtime from object files.

   Copyright (C) 2000-2012, 2014, 2015, 2016, 2017, 2018 Red Hat, Inc.

   This file is part of elfutils.

   Written by Ulrich Drepper <drepper@redhat.com>, 2000.

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

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include <argp.h>

#include <assert.h>

#include <byteswap.h>

#include <endian.h>

#include <fcntl.h>

#include <fnmatch.h>

#include <gelf.h>

#include <libelf.h>

#include <libintl.h>

#include <locale.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdio_ext.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/stat.h>

#include <sys/time.h>

#include <elf-knowledge.h>

#include <libebl.h>

#include "libdwelf.h"

#include <libeu.h>

#include <system.h>

#include <printversion.h>

typedef uint8_t GElf_Byte;

/* Name and version of program.  */

ARGP_PROGRAM_VERSION_HOOK_DEF = print_version;

/* Bug report address.  */

ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT;

/* Values for the parameters which have no short form.  */

#define OPT_REMOVE_COMMENT	0x100

#define OPT_PERMISSIVE		0x101

#define OPT_STRIP_SECTIONS	0x102

#define OPT_RELOC_DEBUG 	0x103

#define OPT_KEEP_SECTION 	0x104

#define OPT_RELOC_DEBUG_ONLY    0x105

/* Definitions of arguments for argp functions.  */

static const struct argp_option options[] =

{

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

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

  { NULL, 'f', "FILE", 0, N_("Extract the removed sections into FILE"), 0 },

  { NULL, 'F', "FILE", 0, N_("Embed name FILE instead of -f argument"), 0 },

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

  { "strip-all", 's', NULL, OPTION_HIDDEN, NULL, 0 },

  { "strip-debug", 'g', NULL, 0, N_("Remove all debugging symbols"), 0 },

  { NULL, 'd', NULL, OPTION_ALIAS, NULL, 0 },

  { NULL, 'S', NULL, OPTION_ALIAS, NULL, 0 },

  { "strip-sections", OPT_STRIP_SECTIONS, NULL, 0,

    N_("Remove section headers (not recommended)"), 0 },

  { "preserve-dates", 'p', NULL, 0,

    N_("Copy modified/access timestamps to the output"), 0 },

  { "reloc-debug-sections", OPT_RELOC_DEBUG, NULL, 0,

    N_("Resolve all trivial relocations between debug sections if the removed sections are placed in a debug file (only relevant for ET_REL files, operation is not reversable, needs -f)"), 0 },

  { "reloc-debug-sections-only", OPT_RELOC_DEBUG_ONLY, NULL, 0,

    N_("Similar to --reloc-debug-sections, but resolve all trivial relocations between debug sections in place.  No other stripping is performed (operation is not reversable, incompatible with -f, -g, --remove-comment and --remove-section)"), 0 },

  { "remove-comment", OPT_REMOVE_COMMENT, NULL, 0,

    N_("Remove .comment section"), 0 },

  { "remove-section", 'R', "SECTION", 0, N_("Remove the named section.  SECTION is an extended wildcard pattern.  May be given more than once.  Only non-allocated sections can be removed."), 0 },

  { "keep-section", OPT_KEEP_SECTION, "SECTION", 0, N_("Keep the named section.  SECTION is an extended wildcard pattern.  May be given more than once."), 0 },

  { "permissive", OPT_PERMISSIVE, NULL, 0,

    N_("Relax a few rules to handle slightly broken ELF files"), 0 },

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

};

/* Short description of program.  */

static const char doc[] = N_("Discard symbols from object files.");

/* Strings for arguments in help texts.  */

static const char args_doc[] = N_("[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

};

/* Print symbols in file named FNAME.  */

static int process_file (const char *fname);

/* Handle one ELF file.  */

static int handle_elf (int fd, Elf *elf, const char *prefix,

		       const char *fname, mode_t mode, struct timespec tvp[2]);

/* Handle all files contained in the archive.  */

static int handle_ar (int fd, Elf *elf, const char *prefix, const char *fname,

		      struct timespec tvp[2]) __attribute__ ((unused));

static int debug_fd = -1;

static char *tmp_debug_fname = NULL;

/* Close debug file descriptor, if opened. And remove temporary debug file.  */

static void cleanup_debug (void);

#define INTERNAL_ERROR(fname) \

  do { \

    cleanup_debug (); \

    error (EXIT_FAILURE, 0, gettext ("%s: INTERNAL ERROR %d (%s): %s"),      \

	   fname, __LINE__, PACKAGE_VERSION, elf_errmsg (-1)); \

  } while (0)

/* Name of the output file.  */

static const char *output_fname;

/* Name of the debug output file.  */

static const char *debug_fname;

/* Name to pretend the debug output file has.  */

static const char *debug_fname_embed;

/* If true output files shall have same date as the input file.  */

static bool preserve_dates;

/* If true .comment sections will be removed.  */

static bool remove_comment;

/* If true remove all debug sections.  */

static bool remove_debug;

/* If true remove all section headers.  */

static bool remove_shdrs;

/* If true relax some ELF rules for input files.  */

static bool permissive;

/* If true perform relocations between debug sections.  */

static bool reloc_debug;

/* If true perform relocations between debug sections only.  */

static bool reloc_debug_only;

/* Sections the user explicitly wants to keep or remove.  */

struct section_pattern

{

  char *pattern;

  struct section_pattern *next;

};

static struct section_pattern *keep_secs = NULL;

static struct section_pattern *remove_secs = NULL;

static void

add_pattern (struct section_pattern **patterns, const char *pattern)

{

  struct section_pattern *p = xmalloc (sizeof *p);

  p->pattern = xstrdup (pattern);

  p->next = *patterns;

  *patterns = p;

}

static void

free_sec_patterns (struct section_pattern *patterns)

{

  struct section_pattern *pattern = patterns;

  while (pattern != NULL)

    {

      struct section_pattern *p = pattern;

      pattern = p->next;

      free (p->pattern);

      free (p);

    }

}

static void

free_patterns (void)

{

  free_sec_patterns (keep_secs);

  free_sec_patterns (remove_secs);

}

static bool

section_name_matches (struct section_pattern *patterns, const char *name)

{

  struct section_pattern *pattern = patterns;

  while (pattern != NULL)

    {

      if (fnmatch (pattern->pattern, name, FNM_EXTMATCH) == 0)

	return true;

      pattern = pattern->next;

    }

  return false;

}

int

main (int argc, char *argv[])

{

  int remaining;

  int result = 0;

  /* We use no threads here which can interfere with handling a stream.  */

  __fsetlocking (stdin, FSETLOCKING_BYCALLER);

  __fsetlocking (stdout, FSETLOCKING_BYCALLER);

  __fsetlocking (stderr, FSETLOCKING_BYCALLER);

  /* Set locale.  */

  setlocale (LC_ALL, "");

  /* Make sure the message catalog can be found.  */

  bindtextdomain (PACKAGE_TARNAME, LOCALEDIR);

  /* Initialize the message catalog.  */

  textdomain (PACKAGE_TARNAME);

  /* Parse and process arguments.  */

  if (argp_parse (&argp, argc, argv, 0, &remaining, NULL) != 0)

    return EXIT_FAILURE;

  if (reloc_debug && debug_fname == NULL)

    error (EXIT_FAILURE, 0,

	   gettext ("--reloc-debug-sections used without -f"));

  if (reloc_debug_only &&

      (debug_fname != NULL || remove_secs != NULL

       || remove_comment == true || remove_debug == true))

    error (EXIT_FAILURE, 0,

	   gettext ("--reloc-debug-sections-only incompatible with -f, -g, --remove-comment and --remove-section"));

  /* Tell the library which version we are expecting.  */

  elf_version (EV_CURRENT);

  if (remaining == argc)

    /* The user didn't specify a name so we use a.out.  */

    result = process_file ("a.out");

  else

    {

      /* If we have seen the '-o' or '-f' option there must be exactly one

	 input file.  */

      if ((output_fname != NULL || debug_fname != NULL)

	  && remaining + 1 < argc)

	error (EXIT_FAILURE, 0, gettext ("\

Only one input file allowed together with '-o' and '-f'"));

      /* Process all the remaining files.  */

      do

	result |= process_file (argv[remaining]);

      while (++remaining < argc);

    }

  free_patterns ();

  return result;

}

/* Handle program arguments.  */

static error_t

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

{

  switch (key)

    {

    case 'f':

      if (debug_fname != NULL)

	{

	  error (0, 0, gettext ("-f option specified twice"));

	  return EINVAL;

	}

      debug_fname = arg;

      break;

    case 'F':

      if (debug_fname_embed != NULL)

	{

	  error (0, 0, gettext ("-F option specified twice"));

	  return EINVAL;

	}

      debug_fname_embed = arg;

      break;

    case 'o':

      if (output_fname != NULL)

	{

	  error (0, 0, gettext ("-o option specified twice"));

	  return EINVAL;

	}

      output_fname = arg;

      break;

    case 'p':

      preserve_dates = true;

      break;

    case OPT_RELOC_DEBUG:

      reloc_debug = true;

      break;

    case OPT_RELOC_DEBUG_ONLY:

      reloc_debug_only = true;

      break;

    case OPT_REMOVE_COMMENT:

      remove_comment = true;

      break;

    case 'R':

      if (fnmatch (arg, ".comment", FNM_EXTMATCH) == 0)

	remove_comment = true;

      add_pattern (&remove_secs, arg);

      break;

    case OPT_KEEP_SECTION:

      add_pattern (&keep_secs, arg);

      break;

    case 'g':

    case 'd':

    case 'S':

      remove_debug = true;

      break;

    case OPT_STRIP_SECTIONS:

      remove_shdrs = true;

      break;

    case OPT_PERMISSIVE:

      permissive = true;

      break;

    case 's':			/* Ignored for compatibility.  */

      break;

    case ARGP_KEY_SUCCESS:

      if (remove_comment == true

	  && section_name_matches (keep_secs, ".comment"))

	{

	  argp_error (state,

		      gettext ("cannot both keep and remove .comment section"));

	  return EINVAL;

	}

      break;

    default:

      return ARGP_ERR_UNKNOWN;

    }

  return 0;

}

static const char *

secndx_name (Elf *elf, size_t ndx)

{

  size_t shstrndx;

  GElf_Shdr mem;

  Elf_Scn *sec = elf_getscn (elf, ndx);

  GElf_Shdr *shdr = gelf_getshdr (sec, &mem;;

  if (shdr == NULL || elf_getshdrstrndx (elf, &shstrndx) < 0)

    return "???";

  return elf_strptr (elf, shstrndx, shdr->sh_name) ?: "???";

}

/* Get the extended section index table data for a symbol table section.  */

static Elf_Data *

get_xndxdata (Elf *elf, Elf_Scn *symscn)

{

  Elf_Data *xndxdata = NULL;

  GElf_Shdr shdr_mem;

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

  if (shdr != NULL && shdr->sh_type == SHT_SYMTAB)

    {

      size_t scnndx = elf_ndxscn (symscn);

      Elf_Scn *xndxscn = NULL;

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

	{

	  GElf_Shdr xndxshdr_mem;

	  GElf_Shdr *xndxshdr = gelf_getshdr (xndxscn, &xndxshdr_mem);

	  if (xndxshdr != NULL

	      && xndxshdr->sh_type == SHT_SYMTAB_SHNDX

	      && xndxshdr->sh_link == scnndx)

	    {

	      xndxdata = elf_getdata (xndxscn, NULL);

	      break;

	    }

	}

    }

  return xndxdata;

}

/* Updates the shdrstrndx for the given Elf by updating the Ehdr and

   possibly the section zero extension field.  Returns zero on success.  */

static int

update_shdrstrndx (Elf *elf, size_t shdrstrndx)

{

  GElf_Ehdr ehdr;

  if (gelf_getehdr (elf, &ehdr) == 0)

    return 1;

  if (shdrstrndx < SHN_LORESERVE)

    ehdr.e_shstrndx = shdrstrndx;

  else

    {

      ehdr.e_shstrndx = SHN_XINDEX;

      Elf_Scn *scn0 = elf_getscn (elf, 0);

      GElf_Shdr shdr0_mem;

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

      if (shdr0 == NULL)

	return 1;

      shdr0->sh_link = shdrstrndx;

      if (gelf_update_shdr (scn0, shdr0) == 0)

	return 1;

    }

  if (unlikely (gelf_update_ehdr (elf, &ehdr) == 0))

    return 1;

  return 0;

}

/* Remove any relocations between debug sections in ET_REL

   for the debug file when requested.  These relocations are always

   zero based between the unallocated sections.  */

static void

remove_debug_relocations (Ebl *ebl, Elf *elf, GElf_Ehdr *ehdr,

			  const char *fname, size_t shstrndx)

{

  Elf_Scn *scn = NULL;

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

    {

      /* We need the actual section and header from the elf

	 not just the cached original in shdr_info because we

	 might want to change the size.  */

      GElf_Shdr shdr_mem;

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

      if (shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA)

	{

	  /* Make sure that this relocation section points to a

	     section to relocate with contents, that isn't

	     allocated and that is a debug section.  */

	  Elf_Scn *tscn = elf_getscn (elf, shdr->sh_info);

	  GElf_Shdr tshdr_mem;

	  GElf_Shdr *tshdr = gelf_getshdr (tscn, &tshdr_mem);

	  if (tshdr->sh_type == SHT_NOBITS

	      || tshdr->sh_size == 0

	      || (tshdr->sh_flags & SHF_ALLOC) != 0)

	    continue;

	  const char *tname =  elf_strptr (elf, shstrndx,

					   tshdr->sh_name);

	  if (! tname || ! ebl_debugscn_p (ebl, tname))

	    continue;

	  /* OK, lets relocate all trivial cross debug section

	     relocations. */

	  Elf_Data *reldata = elf_getdata (scn, NULL);

	  if (reldata == NULL || reldata->d_buf == NULL)

	    INTERNAL_ERROR (fname);

	  /* Make sure we adjust the uncompressed debug data

	     (and recompress if necessary at the end).  */

	  GElf_Chdr tchdr;

	  int tcompress_type = 0;

	  bool is_gnu_compressed = false;

	  if (strncmp (tname, ".zdebug", strlen ("zdebug")) == 0)

	    {

	      is_gnu_compressed = true;

	      if (elf_compress_gnu (tscn, 0, 0) != 1)

		INTERNAL_ERROR (fname);

	    }

	  else

	    {

	      if (gelf_getchdr (tscn, &tchdr) != NULL)

		{

		  tcompress_type = tchdr.ch_type;

		  if (elf_compress (tscn, 0, 0) != 1)

		    INTERNAL_ERROR (fname);

		}

	    }

	  Elf_Data *tdata = elf_getdata (tscn, NULL);

	  if (tdata == NULL || tdata->d_buf == NULL

	      || tdata->d_type != ELF_T_BYTE)

	    INTERNAL_ERROR (fname);

	  /* Pick up the symbol table and shndx table to

	     resolve relocation symbol indexes.  */

	  Elf64_Word symt = shdr->sh_link;

	  Elf_Data *symdata, *xndxdata;

	  Elf_Scn * symscn = elf_getscn (elf, symt);

	  symdata = elf_getdata (symscn, NULL);

	  xndxdata = get_xndxdata (elf, symscn);

	  if (symdata == NULL)

	    INTERNAL_ERROR (fname);

	  /* Apply one relocation.  Returns true when trivial

	     relocation actually done.  */

	  bool relocate (GElf_Addr offset, const GElf_Sxword addend,

			 bool is_rela, int rtype, int symndx)

	  {

	    /* R_*_NONE relocs can always just be removed.  */

	    if (rtype == 0)

	      return true;

	    /* We only do simple absolute relocations.  */

	    int addsub = 0;

	    Elf_Type type = ebl_reloc_simple_type (ebl, rtype, &addsub);

	    if (type == ELF_T_NUM)

	      return false;

	    /* These are the types we can relocate.  */

#define TYPES   DO_TYPE (BYTE, Byte); DO_TYPE (HALF, Half);		\

		DO_TYPE (WORD, Word); DO_TYPE (SWORD, Sword);		\

		DO_TYPE (XWORD, Xword); DO_TYPE (SXWORD, Sxword)

	    /* And only for relocations against other debug sections.  */

	    GElf_Sym sym_mem;

	    Elf32_Word xndx;

	    GElf_Sym *sym = gelf_getsymshndx (symdata, xndxdata,

					      symndx, &sym_mem,

					      &xndx);

	    Elf32_Word sec = (sym->st_shndx == SHN_XINDEX

			      ? xndx : sym->st_shndx);

	    if (ebl_debugscn_p (ebl, secndx_name (elf, sec)))

	      {

		size_t size;

#define DO_TYPE(NAME, Name) GElf_##Name Name;

		union { TYPES; } tmpbuf;

#undef DO_TYPE

		switch (type)

		  {

#define DO_TYPE(NAME, Name)				\

		    case ELF_T_##NAME:			\

		      size = sizeof (GElf_##Name);	\

		      tmpbuf.Name = 0;			\

		      break;

		    TYPES;

#undef DO_TYPE

		  default:

		    return false;

		  }

		if (offset > tdata->d_size

		    || tdata->d_size - offset < size)

		  {

		    cleanup_debug ();

		    error (EXIT_FAILURE, 0, gettext ("bad relocation"));

		  }

		/* When the symbol value is zero then for SHT_REL

		   sections this is all that needs to be checked.

		   The addend is contained in the original data at

		   the offset already.  So if the (section) symbol

		   address is zero and the given addend is zero

		   just remove the relocation, it isn't needed

		   anymore.  */

		if (addend == 0 && sym->st_value == 0)

		  return true;

		Elf_Data tmpdata =

		  {

		    .d_type = type,

		    .d_buf = &tmpbuf,

		    .d_size = size,

		    .d_version = EV_CURRENT,

		  };

		Elf_Data rdata =

		  {

		    .d_type = type,

		    .d_buf = tdata->d_buf + offset,

		    .d_size = size,

		    .d_version = EV_CURRENT,

		  };

		GElf_Addr value = sym->st_value;

		if (is_rela)

		  {

		    /* For SHT_RELA sections we just take the

		       given addend and add it to the value.  */

		    value += addend;

		    /* For ADD/SUB relocations we need to fetch the

		       current section contents.  */

		    if (addsub != 0)

		      {

			Elf_Data *d = gelf_xlatetom (elf, &tmpdata,

						     &rdata,

						     ehdr->e_ident[EI_DATA]);

			if (d == NULL)

			  INTERNAL_ERROR (fname);

			assert (d == &tmpdata);

		      }

		  }

		else

		  {

		    /* For SHT_REL sections we have to peek at

		       what is already in the section at the given

		       offset to get the addend.  */

		    Elf_Data *d = gelf_xlatetom (elf, &tmpdata,

						 &rdata,

						 ehdr->e_ident[EI_DATA]);

		    if (d == NULL)

		      INTERNAL_ERROR (fname);

		    assert (d == &tmpdata);

		  }

		switch (type)

		  {

#define DO_TYPE(NAME, Name)					 \

		    case ELF_T_##NAME:				 \

		      if (addsub < 0)				 \

			tmpbuf.Name -= (GElf_##Name) value;	 \

		      else					 \

			tmpbuf.Name += (GElf_##Name) value;	 \

		      break;

		    TYPES;

#undef DO_TYPE

		  default:

		    abort ();

		  }

		/* Now finally put in the new value.  */

		Elf_Data *s = gelf_xlatetof (elf, &rdata,

					     &tmpdata,

					     ehdr->e_ident[EI_DATA]);

		if (s == NULL)

		  INTERNAL_ERROR (fname);

		assert (s == &rdata);

		return true;

	      }

	    return false;

	  }

	  if (shdr->sh_entsize == 0)

	    INTERNAL_ERROR (fname);

	  size_t nrels = shdr->sh_size / shdr->sh_entsize;

	  size_t next = 0;

	  if (shdr->sh_type == SHT_REL)

	    for (size_t relidx = 0; relidx < nrels; ++relidx)

	      {

		GElf_Rel rel_mem;

		GElf_Rel *r = gelf_getrel (reldata, relidx, &rel_mem);

		if (! relocate (r->r_offset, 0, false,

				GELF_R_TYPE (r->r_info),

				GELF_R_SYM (r->r_info)))

		  {

		    if (relidx != next)

		      gelf_update_rel (reldata, next, r);

		    ++next;

		  }

	      }

	  else

	    for (size_t relidx = 0; relidx < nrels; ++relidx)

	      {

		GElf_Rela rela_mem;

		GElf_Rela *r = gelf_getrela (reldata, relidx, &rela_mem);

		if (! relocate (r->r_offset, r->r_addend, true,

				GELF_R_TYPE (r->r_info),

				GELF_R_SYM (r->r_info)))

		  {

		    if (relidx != next)

		      gelf_update_rela (reldata, next, r);

		    ++next;

		  }

	      }

	  nrels = next;

	  shdr->sh_size = reldata->d_size = nrels * shdr->sh_entsize;

	  gelf_update_shdr (scn, shdr);

	  if (is_gnu_compressed)

	    {

	      if (elf_compress_gnu (tscn, 1, ELF_CHF_FORCE) != 1)

		INTERNAL_ERROR (fname);

	    }

	  else if (tcompress_type != 0)

	    {

	      if (elf_compress (tscn, tcompress_type, ELF_CHF_FORCE) != 1)

		INTERNAL_ERROR (fname);

	    }

	}

    }

}

static int

process_file (const char *fname)

{

  /* If we have to preserve the modify and access timestamps get them

     now.  We cannot use fstat() after opening the file since the open

     would change the access time.  */

  struct stat pre_st;

  struct timespec tv[2];

 again:

  if (preserve_dates)

    {

      if (stat (fname, &pre_st) != 0)

	{

	  error (0, errno, gettext ("cannot stat input file '%s'"), fname);

	  return 1;

	}

      /* If we have to preserve the timestamp, we need it in the

	 format utimes() understands.  */

      tv[0] = pre_st.st_atim;

      tv[1] = pre_st.st_mtim;

    }

  /* Open the file.  */

  int fd = open (fname, output_fname == NULL ? O_RDWR : O_RDONLY);

  if (fd == -1)

    {

      error (0, errno, gettext ("while opening '%s'"), fname);

      return 1;

    }

  /* We always use fstat() even if we called stat() before.  This is

     done to make sure the information returned by stat() is for the

     same file.  */

  struct stat st;

  if (fstat (fd, &st) != 0)

    {

      error (0, errno, gettext ("cannot stat input file '%s'"), fname);

      return 1;

    }

  /* Paranoid mode on.  */

  if (preserve_dates

      && (st.st_ino != pre_st.st_ino || st.st_dev != pre_st.st_dev))

    {

      /* We detected a race.  Try again.  */

      close (fd);

      goto again;

    }

  /* Now get the ELF descriptor.  */

  Elf *elf = elf_begin (fd, output_fname == NULL ? ELF_C_RDWR : ELF_C_READ,

			NULL);

  int result;

  switch (elf_kind (elf))

    {

    case ELF_K_ELF:

      result = handle_elf (fd, elf, NULL, fname, st.st_mode & ACCESSPERMS,

			   preserve_dates ? tv : NULL);

      break;

    case ELF_K_AR:

      /* It is not possible to strip the content of an archive direct

	 the output to a specific file.  */

      if (unlikely (output_fname != NULL || debug_fname != NULL))

	{

	  error (0, 0, gettext ("%s: cannot use -o or -f when stripping archive"),

		 fname);

	  result = 1;

	}

      else

	{

	  /* We would like to support ar archives, but currently it just

	     doesn't work at all since we call elf_clone on the members

	     which doesn't really support ar members.

	     result = handle_ar (fd, elf, NULL, fname,

				 preserve_dates ? tv : NULL);

	   */

	  error (0, 0, gettext ("%s: no support for stripping archive"),

		 fname);

	  result = 1;

	}

      break;

    default:

      error (0, 0, gettext ("%s: File format not recognized"), fname);

      result = 1;

      break;

    }

  if (unlikely (elf_end (elf) != 0))

    INTERNAL_ERROR (fname);

  close (fd);

  return result;

}

/* Processing for --reloc-debug-sections-only.  */

static int

handle_debug_relocs (Elf *elf, Ebl *ebl, Elf *new_elf,

		     GElf_Ehdr *ehdr, const char *fname, size_t shstrndx,

		     GElf_Off *last_offset, GElf_Xword *last_size)

{

  /* Copy over the ELF header.  */

  if (gelf_update_ehdr (new_elf, ehdr) == 0)

    {

      error (0, 0, "couldn't update new ehdr: %s", elf_errmsg (-1));

      return 1;

    }

  /* Copy over sections and record end of allocated sections.  */

  GElf_Off lastoffset = 0;

  Elf_Scn *scn = NULL;

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

    {

      /* Get the header.  */

      GElf_Shdr shdr;

      if (gelf_getshdr (scn, &shdr) == NULL)

	{

	  error (0, 0, "couldn't get shdr: %s", elf_errmsg (-1));

	  return 1;

	}

      /* Create new section.  */

      Elf_Scn *new_scn = elf_newscn (new_elf);

      if (new_scn == NULL)

	{

	  error (0, 0, "couldn't create new section: %s", elf_errmsg (-1));

	  return 1;

	}

      if (gelf_update_shdr (new_scn, &shdr) == 0)

	{

	  error (0, 0, "couldn't update shdr: %s", elf_errmsg (-1));

	  return 1;

	}

      /* Copy over section data.  */

      Elf_Data *data = NULL;

      while ((data = elf_getdata (scn, data)) != NULL)

	{

	  Elf_Data *new_data = elf_newdata (new_scn);

	  if (new_data == NULL)

	    {

	      error (0, 0, "couldn't create new section data: %s",

		     elf_errmsg (-1));

	      return 1;

	    }

	  *new_data = *data;

	}

      /* Record last offset of allocated section.  */

      if ((shdr.sh_flags & SHF_ALLOC) != 0)

	{

	  GElf_Off filesz = (shdr.sh_type != SHT_NOBITS

			     ? shdr.sh_size : 0);

	  if (lastoffset < shdr.sh_offset + filesz)

	    lastoffset = shdr.sh_offset + filesz;

	}

    }

  /* Make sure section header name table is setup correctly, we'll

     need it to determine whether to relocate sections.  */

  if (update_shdrstrndx (new_elf, shstrndx) != 0)

    {

      error (0, 0, "error updating shdrstrndx: %s", elf_errmsg (-1));

      return 1;