* go.test/go-test.exp (go-set-goarch): Use amd64p32 on x32.

[official-gcc.git] / libiberty / simple-object-elf.c

/* simple-object-elf.c -- routines to manipulate ELF object files.
   Copyright (C) 2010-2018 Free Software Foundation, Inc.
   Written by Ian Lance Taylor, Google.

This program 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 2, or (at your option) any
later version.

This program 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, write to the Free Software
Foundation, 51 Franklin Street - Fifth Floor,
Boston, MA 02110-1301, USA.  */

#include "config.h"
#include "libiberty.h"
#include "simple-object.h"

#include <errno.h>
/* mingw.org's MinGW doesn't have ENOTSUP.  */
#ifndef ENOTSUP
# define ENOTSUP ENOSYS
#endif
#include <stddef.h>

#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif

#ifdef HAVE_STDINT_H
#include <stdint.h>
#endif

#ifdef HAVE_STRING_H
#include <string.h>
#endif

#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif

#include "simple-object-common.h"

/* ELF structures and constants.  */

/* 32-bit ELF file header.  */

typedef struct {
  unsigned char e_ident[16];            /* ELF "magic number" */
  unsigned char e_type[2];              /* Identifies object file type */
  unsigned char e_machine[2];           /* Specifies required architecture */
  unsigned char e_version[4];           /* Identifies object file version */
  unsigned char e_entry[4];             /* Entry point virtual address */
  unsigned char e_phoff[4];             /* Program header table file offset */
  unsigned char e_shoff[4];             /* Section header table file offset */
  unsigned char e_flags[4];             /* Processor-specific flags */
  unsigned char e_ehsize[2];            /* ELF header size in bytes */
  unsigned char e_phentsize[2];         /* Program header table entry size */
  unsigned char e_phnum[2];             /* Program header table entry count */
  unsigned char e_shentsize[2];         /* Section header table entry size */
  unsigned char e_shnum[2];             /* Section header table entry count */
  unsigned char e_shstrndx[2];          /* Section header string table index */
} Elf32_External_Ehdr;

/* 64-bit ELF file header.  */

typedef struct {
  unsigned char e_ident[16];            /* ELF "magic number" */
  unsigned char e_type[2];              /* Identifies object file type */
  unsigned char e_machine[2];           /* Specifies required architecture */
  unsigned char e_version[4];           /* Identifies object file version */
  unsigned char e_entry[8];             /* Entry point virtual address */
  unsigned char e_phoff[8];             /* Program header table file offset */
  unsigned char e_shoff[8];             /* Section header table file offset */
  unsigned char e_flags[4];             /* Processor-specific flags */
  unsigned char e_ehsize[2];            /* ELF header size in bytes */
  unsigned char e_phentsize[2];         /* Program header table entry size */
  unsigned char e_phnum[2];             /* Program header table entry count */
  unsigned char e_shentsize[2];         /* Section header table entry size */
  unsigned char e_shnum[2];             /* Section header table entry count */
  unsigned char e_shstrndx[2];          /* Section header string table index */
} Elf64_External_Ehdr;

/* Indexes and values in e_ident field of Ehdr.  */

#define EI_MAG0         0       /* File identification byte 0 index */
#define ELFMAG0            0x7F /* Magic number byte 0 */

#define EI_MAG1         1       /* File identification byte 1 index */
#define ELFMAG1             'E' /* Magic number byte 1 */

#define EI_MAG2         2       /* File identification byte 2 index */
#define ELFMAG2             'L' /* Magic number byte 2 */

#define EI_MAG3         3       /* File identification byte 3 index */
#define ELFMAG3             'F' /* Magic number byte 3 */

#define EI_CLASS        4       /* File class */
#define ELFCLASSNONE          0 /* Invalid class */
#define ELFCLASS32            1 /* 32-bit objects */
#define ELFCLASS64            2 /* 64-bit objects */

#define EI_DATA         5       /* Data encoding */
#define ELFDATANONE           0 /* Invalid data encoding */
#define ELFDATA2LSB           1 /* 2's complement, little endian */
#define ELFDATA2MSB           2 /* 2's complement, big endian */

#define EI_VERSION      6       /* File version */
#define EV_CURRENT      1               /* Current version */

#define EI_OSABI        7       /* Operating System/ABI indication */

/* Values for e_type field of Ehdr.  */

#define ET_REL          1       /* Relocatable file */

/* Values for e_machine field of Ehdr.  */

#define EM_SPARC          2     /* SUN SPARC */
#define EM_SPARC32PLUS   18     /* Sun's "v8plus" */

/* Special section index values.  */

#define SHN_UNDEF       0               /* Undefined section */
#define SHN_LORESERVE   0xFF00          /* Begin range of reserved indices */
#define SHN_COMMON      0xFFF2  /* Associated symbol is in common */
#define SHN_XINDEX      0xFFFF          /* Section index is held elsewhere */
#define SHN_HIRESERVE   0xffff          /* End of reserved indices */


/* 32-bit ELF program header.  */

typedef struct {
  unsigned char p_type[4];              /* Identifies program segment type */
  unsigned char p_offset[4];            /* Segment file offset */
  unsigned char p_vaddr[4];             /* Segment virtual address */
  unsigned char p_paddr[4];             /* Segment physical address */
  unsigned char p_filesz[4];            /* Segment size in file */
  unsigned char p_memsz[4];             /* Segment size in memory */
  unsigned char p_flags[4];             /* Segment flags */
  unsigned char p_align[4];             /* Segment alignment, file & memory */
} Elf32_External_Phdr;

/* 64-bit ELF program header.  */

typedef struct {
  unsigned char p_type[4];              /* Identifies program segment type */
  unsigned char p_flags[4];             /* Segment flags */
  unsigned char p_offset[8];            /* Segment file offset */
  unsigned char p_vaddr[8];             /* Segment virtual address */
  unsigned char p_paddr[8];             /* Segment physical address */
  unsigned char p_filesz[8];            /* Segment size in file */
  unsigned char p_memsz[8];             /* Segment size in memory */
  unsigned char p_align[8];             /* Segment alignment, file & memory */
} Elf64_External_Phdr;

/* 32-bit ELF section header */

typedef struct {
  unsigned char sh_name[4];             /* Section name, index in string tbl */
  unsigned char sh_type[4];             /* Type of section */
  unsigned char sh_flags[4];            /* Miscellaneous section attributes */
  unsigned char sh_addr[4];             /* Section virtual addr at execution */
  unsigned char sh_offset[4];           /* Section file offset */
  unsigned char sh_size[4];             /* Size of section in bytes */
  unsigned char sh_link[4];             /* Index of another section */
  unsigned char sh_info[4];             /* Additional section information */
  unsigned char sh_addralign[4];        /* Section alignment */
  unsigned char sh_entsize[4];          /* Entry size if section holds table */
} Elf32_External_Shdr;

/* 64-bit ELF section header.  */

typedef struct {
  unsigned char sh_name[4];             /* Section name, index in string tbl */
  unsigned char sh_type[4];             /* Type of section */
  unsigned char sh_flags[8];            /* Miscellaneous section attributes */
  unsigned char sh_addr[8];             /* Section virtual addr at execution */
  unsigned char sh_offset[8];           /* Section file offset */
  unsigned char sh_size[8];             /* Size of section in bytes */
  unsigned char sh_link[4];             /* Index of another section */
  unsigned char sh_info[4];             /* Additional section information */
  unsigned char sh_addralign[8];        /* Section alignment */
  unsigned char sh_entsize[8];          /* Entry size if section holds table */
} Elf64_External_Shdr;

/* Values for sh_type field.  */

#define SHT_NULL        0               /* Section header table entry unused */
#define SHT_PROGBITS    1               /* Program data */
#define SHT_SYMTAB      2               /* Link editing symbol table */
#define SHT_STRTAB      3               /* A string table */
#define SHT_RELA        4               /* Relocation entries with addends */
#define SHT_REL         9               /* Relocation entries, no addends */
#define SHT_GROUP       17              /* Section contains a section group */
#define SHT_SYMTAB_SHNDX 18             /* Extended section indeces */

/* Values for sh_flags field.  */

#define SHF_INFO_LINK   0x00000040      /* `sh_info' contains SHT index */
#define SHF_EXECINSTR   0x00000004      /* Executable section.  */
#define SHF_EXCLUDE     0x80000000      /* Link editor is to exclude this
                                           section from executable and
                                           shared library that it builds
                                           when those objects are not to be
                                           further relocated.  */
/* Symbol table entry.  */

typedef struct
{
  unsigned char st_name[4];                /* Symbol name (string tbl index) */
  unsigned char st_value[4];               /* Symbol value */
  unsigned char st_size[4];                /* Symbol size */
  unsigned char st_info;                /* Symbol type and binding */
  unsigned char st_other;               /* Symbol visibility */
  unsigned char st_shndx[2];               /* Section index */
} Elf32_External_Sym;

typedef struct
{
  unsigned char st_name[4];                /* Symbol name (string tbl index) */
  unsigned char st_info;                /* Symbol type and binding */
  unsigned char st_other;               /* Symbol visibility */
  unsigned char st_shndx[2];               /* Section index */
  unsigned char st_value[8];               /* Symbol value */
  unsigned char st_size[8];                /* Symbol size */
} Elf64_External_Sym;

#define ELF_ST_BIND(val)              (((unsigned char) (val)) >> 4)
#define ELF_ST_TYPE(val)              ((val) & 0xf)
#define ELF_ST_INFO(bind, type)       (((bind) << 4) + ((type) & 0xf))

#define STT_NOTYPE      0       /* Symbol type is unspecified */
#define STT_OBJECT      1       /* Symbol is a data object */
#define STT_FUNC        2       /* Symbol is a code object */
#define STT_TLS         6       /* Thread local data object */
#define STT_GNU_IFUNC   10      /* Symbol is an indirect code object */

#define STB_LOCAL       0       /* Local symbol */
#define STB_GLOBAL      1       /* Global symbol */
#define STB_WEAK        2       /* Weak global */

#define STV_DEFAULT     0       /* Visibility is specified by binding type */
#define STV_HIDDEN      2       /* Can only be seen inside currect component */

/* Functions to fetch and store different ELF types, depending on the
   endianness and size.  */

struct elf_type_functions
{
  unsigned short (*fetch_Elf_Half) (const unsigned char *);
  unsigned int (*fetch_Elf_Word) (const unsigned char *);
  ulong_type (*fetch_Elf_Addr) (const unsigned char *);
  void (*set_Elf_Half) (unsigned char *, unsigned short);
  void (*set_Elf_Word) (unsigned char *, unsigned int);
  void (*set_Elf_Addr) (unsigned char *, ulong_type);
};

static const struct elf_type_functions elf_big_32_functions =
{
  simple_object_fetch_big_16,
  simple_object_fetch_big_32,
  simple_object_fetch_big_32_ulong,
  simple_object_set_big_16,
  simple_object_set_big_32,
  simple_object_set_big_32_ulong
};

static const struct elf_type_functions elf_little_32_functions =
{
  simple_object_fetch_little_16,
  simple_object_fetch_little_32,
  simple_object_fetch_little_32_ulong,
  simple_object_set_little_16,
  simple_object_set_little_32,
  simple_object_set_little_32_ulong
};

#ifdef UNSIGNED_64BIT_TYPE

static const struct elf_type_functions elf_big_64_functions =
{
  simple_object_fetch_big_16,
  simple_object_fetch_big_32,
  simple_object_fetch_big_64,
  simple_object_set_big_16,
  simple_object_set_big_32,
  simple_object_set_big_64
};

static const struct elf_type_functions elf_little_64_functions =
{
  simple_object_fetch_little_16,
  simple_object_fetch_little_32,
  simple_object_fetch_little_64,
  simple_object_set_little_16,
  simple_object_set_little_32,
  simple_object_set_little_64
};

#endif

/* Hideous macro to fetch the value of a field from an external ELF
   struct of some sort.  TYPEFUNCS is the set of type functions.
   BUFFER points to the external data.  STRUCTTYPE is the appropriate
   struct type.  FIELD is a field within the struct.  TYPE is the type
   of the field in the struct: Elf_Half, Elf_Word, or Elf_Addr.  */

#define ELF_FETCH_STRUCT_FIELD(TYPEFUNCS, STRUCTTYPE, FIELD, BUFFER, TYPE) \
  ((TYPEFUNCS)->fetch_ ## TYPE ((BUFFER) + offsetof (STRUCTTYPE, FIELD)))

/* Even more hideous macro to fetch the value of FIELD from BUFFER.
   SIZE is 32 or 64.  STRUCTTYPE is the name of the struct from
   elf/external.h: Ehdr, Shdr, etc.  FIELD is the name of a field in
   the struct.  TYPE is the type of the field in the struct: Elf_Half,
   Elf_Word, or Elf_Addr.  */

#define ELF_FETCH_SIZED_FIELD(TYPEFUNCS, SIZE, STRUCTTYPE, BUFFER,      \
                              FIELD, TYPE)                              \
  ELF_FETCH_STRUCT_FIELD (TYPEFUNCS,                                    \
                          Elf ## SIZE ## _External_ ## STRUCTTYPE,      \
                          FIELD, BUFFER, TYPE)

/* Like ELF_FETCH_SIZED_FIELD but taking an ELFCLASS value.  */

#define ELF_FETCH_FIELD(TYPEFUNCS, CLASS, STRUCTTYPE, BUFFER,           \
                        FIELD, TYPE)                                    \
  ((CLASS) == ELFCLASS32                                                \
    ? ELF_FETCH_SIZED_FIELD (TYPEFUNCS, 32, STRUCTTYPE, BUFFER, FIELD,  \
                             TYPE)                                      \
    : ELF_FETCH_SIZED_FIELD (TYPEFUNCS, 64, STRUCTTYPE, BUFFER, FIELD,  \
                             TYPE))

/* Hideous macro to set the value of a field in an external ELF
   structure to VAL.  TYPEFUNCS is the set of type functions.  BUFFER
   points to the external data.  STRUCTTYPE is the appropriate
   structure type.  FIELD is a field within the struct.  TYPE is the
   type of the field in the struct: Elf_Half, Elf_Word, or
   Elf_Addr.  */

#define ELF_SET_STRUCT_FIELD(TYPEFUNCS, STRUCTTYPE, FIELD, BUFFER, TYPE, VAL) \
  (TYPEFUNCS)->set_ ## TYPE ((BUFFER) + offsetof (STRUCTTYPE, FIELD), (VAL))

/* Even more hideous macro to set the value of FIELD in BUFFER to VAL.
   SIZE is 32 or 64.  STRUCTTYPE is the name of the struct from
   elf/external.h: Ehdr, Shdr, etc.  FIELD is the name of a field in
   the struct.  TYPE is the type of the field in the struct: Elf_Half,
   Elf_Word, or Elf_Addr.  */

#define ELF_SET_SIZED_FIELD(TYPEFUNCS, SIZE, STRUCTTYPE, BUFFER, FIELD, \
                            TYPE, VAL)                                  \
  ELF_SET_STRUCT_FIELD (TYPEFUNCS,                                      \
                        Elf ## SIZE ## _External_ ## STRUCTTYPE,        \
                        FIELD, BUFFER, TYPE, VAL)

/* Like ELF_SET_SIZED_FIELD but taking an ELFCLASS value.  */

#define ELF_SET_FIELD(TYPEFUNCS, CLASS, STRUCTTYPE, BUFFER, FIELD,      \
                      TYPE, VAL)                                        \
  ((CLASS) == ELFCLASS32                                                \
    ? ELF_SET_SIZED_FIELD (TYPEFUNCS, 32, STRUCTTYPE, BUFFER, FIELD,    \
                           TYPE, VAL)                                   \
    : ELF_SET_SIZED_FIELD (TYPEFUNCS, 64, STRUCTTYPE, BUFFER, FIELD,    \
                           TYPE, VAL))

/* Private data for an simple_object_read.  */

struct simple_object_elf_read
{
  /* Type functions.  */
  const struct elf_type_functions* type_functions;
  /* Elf data.  */
  unsigned char ei_data;
  /* Elf class.  */
  unsigned char ei_class;
  /* ELF OS ABI.  */
  unsigned char ei_osabi;
  /* Elf machine number.  */
  unsigned short machine;
  /* Processor specific flags.  */
  unsigned int flags;
  /* File offset of section headers.  */
  ulong_type shoff;
  /* Number of sections.  */
  unsigned int shnum;
  /* Index of string table section header.  */
  unsigned int shstrndx;
};

/* Private data for an simple_object_attributes.  */

struct simple_object_elf_attributes
{
  /* Type functions.  */
  const struct elf_type_functions* type_functions;
  /* Elf data.  */
  unsigned char ei_data;
  /* Elf class.  */
  unsigned char ei_class;
  /* ELF OS ABI.  */
  unsigned char ei_osabi;
  /* Elf machine number.  */
  unsigned short machine;
  /* Processor specific flags.  */
  unsigned int flags;
};

/* Private data for an simple_object_write.  */

struct simple_object_elf_write
{
  struct simple_object_elf_attributes attrs;
  unsigned char *shdrs;
};

/* See if we have an ELF file.  */

static void *
simple_object_elf_match (unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN],
                         int descriptor, off_t offset,
                         const char *segment_name ATTRIBUTE_UNUSED,
                         const char **errmsg, int *err)
{
  unsigned char ei_data;
  unsigned char ei_class;
  const struct elf_type_functions *type_functions;
  unsigned char ehdr[sizeof (Elf64_External_Ehdr)];
  struct simple_object_elf_read *eor;

  if (header[EI_MAG0] != ELFMAG0
      || header[EI_MAG1] != ELFMAG1
      || header[EI_MAG2] != ELFMAG2
      || header[EI_MAG3] != ELFMAG3
      || header[EI_VERSION] != EV_CURRENT)
    {
      *errmsg = NULL;
      *err = 0;
      return NULL;
    }

  ei_data = header[EI_DATA];
  if (ei_data != ELFDATA2LSB && ei_data != ELFDATA2MSB)
    {
      *errmsg = "unknown ELF endianness";
      *err = 0;
      return NULL;
    }

  ei_class = header[EI_CLASS];
  switch (ei_class)
    {
    case ELFCLASS32:
      type_functions = (ei_data == ELFDATA2LSB
                        ? &elf_little_32_functions
                        : &elf_big_32_functions);
      break;

    case ELFCLASS64:
#ifndef UNSIGNED_64BIT_TYPE
      *errmsg = "64-bit ELF objects not supported";
      *err = 0;
      return NULL;
#else
      type_functions = (ei_data == ELFDATA2LSB
                        ? &elf_little_64_functions
                        : &elf_big_64_functions);
      break;
#endif

    default:
      *errmsg = "unrecognized ELF size";
      *err = 0;
      return NULL;
    }

  if (!simple_object_internal_read (descriptor, offset, ehdr, sizeof ehdr,
                                    errmsg, err))
    return NULL;

  eor = XNEW (struct simple_object_elf_read);
  eor->type_functions = type_functions;
  eor->ei_data = ei_data;
  eor->ei_class = ei_class;
  eor->ei_osabi = header[EI_OSABI];
  eor->machine = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
                                  e_machine, Elf_Half);
  eor->flags = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
                                e_flags, Elf_Word);
  eor->shoff = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
                                e_shoff, Elf_Addr);
  eor->shnum = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
                                e_shnum, Elf_Half);
  eor->shstrndx = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
                                   e_shstrndx, Elf_Half);

  if ((eor->shnum == 0 || eor->shstrndx == SHN_XINDEX)
      && eor->shoff != 0)
    {
      unsigned char shdr[sizeof (Elf64_External_Shdr)];

      /* Object file has more than 0xffff sections.  */

      if (!simple_object_internal_read (descriptor, offset + eor->shoff, shdr,
                                        (ei_class == ELFCLASS32
                                         ? sizeof (Elf32_External_Shdr)
                                         : sizeof (Elf64_External_Shdr)),
                                        errmsg, err))
        {
          XDELETE (eor);
          return NULL;
        }

      if (eor->shnum == 0)
        eor->shnum = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                      shdr, sh_size, Elf_Addr);

      if (eor->shstrndx == SHN_XINDEX)
        {
          eor->shstrndx = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                           shdr, sh_link, Elf_Word);

          /* Versions of the GNU binutils between 2.12 and 2.18 did
             not handle objects with more than SHN_LORESERVE sections
             correctly.  All large section indexes were offset by
             0x100.  There is more information at
             http://sourceware.org/bugzilla/show_bug.cgi?id-5900 .
             Fortunately these object files are easy to detect, as the
             GNU binutils always put the section header string table
             near the end of the list of sections.  Thus if the
             section header string table index is larger than the
             number of sections, then we know we have to subtract
             0x100 to get the real section index.  */
          if (eor->shstrndx >= eor->shnum
              && eor->shstrndx >= SHN_LORESERVE + 0x100)
            eor->shstrndx -= 0x100;
        }
    }

  if (eor->shstrndx >= eor->shnum)
    {
      *errmsg = "invalid ELF shstrndx >= shnum";
      *err = 0;
      XDELETE (eor);
      return NULL;
    }

  return (void *) eor;
}

/* Find all sections in an ELF file.  */

static const char *
simple_object_elf_find_sections (simple_object_read *sobj,
                                 int (*pfn) (void *, const char *,
                                             off_t offset, off_t length),
                                 void *data,
                                 int *err)
{
  struct simple_object_elf_read *eor =
    (struct simple_object_elf_read *) sobj->data;
  const struct elf_type_functions *type_functions = eor->type_functions;
  unsigned char ei_class = eor->ei_class;
  size_t shdr_size;
  unsigned int shnum;
  unsigned char *shdrs;
  const char *errmsg;
  unsigned char *shstrhdr;
  size_t name_size;
  off_t shstroff;
  unsigned char *names;
  unsigned int i;

  shdr_size = (ei_class == ELFCLASS32
               ? sizeof (Elf32_External_Shdr)
               : sizeof (Elf64_External_Shdr));

  /* Read the section headers.  We skip section 0, which is not a
     useful section.  */

  shnum = eor->shnum;
  shdrs = XNEWVEC (unsigned char, shdr_size * (shnum - 1));

  if (!simple_object_internal_read (sobj->descriptor,
                                    sobj->offset + eor->shoff + shdr_size,
                                    shdrs,
                                    shdr_size * (shnum - 1),
                                    &errmsg, err))
    {
      XDELETEVEC (shdrs);
      return errmsg;
    }

  /* Read the section names.  */

  shstrhdr = shdrs + (eor->shstrndx - 1) * shdr_size;
  name_size = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                               shstrhdr, sh_size, Elf_Addr);
  shstroff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                              shstrhdr, sh_offset, Elf_Addr);
  names = XNEWVEC (unsigned char, name_size);
  if (!simple_object_internal_read (sobj->descriptor,
                                    sobj->offset + shstroff,
                                    names, name_size, &errmsg, err))
    {
      XDELETEVEC (names);
      XDELETEVEC (shdrs);
      return errmsg;
    }

  for (i = 1; i < shnum; ++i)
    {
      unsigned char *shdr;
      unsigned int sh_name;
      const char *name;
      off_t offset;
      off_t length;

      shdr = shdrs + (i - 1) * shdr_size;
      sh_name = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                 shdr, sh_name, Elf_Word);
      if (sh_name >= name_size)
        {
          *err = 0;
          XDELETEVEC (names);
          XDELETEVEC (shdrs);
          return "ELF section name out of range";
        }

      name = (const char *) names + sh_name;
      offset = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                shdr, sh_offset, Elf_Addr);
      length = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                shdr, sh_size, Elf_Addr);

      if (!(*pfn) (data, name, offset, length))
        break;
    }

  XDELETEVEC (names);
  XDELETEVEC (shdrs);

  return NULL;
}

/* Fetch the attributes for an simple_object_read.  */

static void *
simple_object_elf_fetch_attributes (simple_object_read *sobj,
                                    const char **errmsg ATTRIBUTE_UNUSED,
                                    int *err ATTRIBUTE_UNUSED)
{
  struct simple_object_elf_read *eor =
    (struct simple_object_elf_read *) sobj->data;
  struct simple_object_elf_attributes *ret;

  ret = XNEW (struct simple_object_elf_attributes);
  ret->type_functions = eor->type_functions;
  ret->ei_data = eor->ei_data;
  ret->ei_class = eor->ei_class;
  ret->ei_osabi = eor->ei_osabi;
  ret->machine = eor->machine;
  ret->flags = eor->flags;
  return ret;
}

/* Release the privata data for an simple_object_read.  */

static void
simple_object_elf_release_read (void *data)
{
  XDELETE (data);
}

/* Compare two attributes structures.  */

static const char *
simple_object_elf_attributes_merge (void *todata, void *fromdata, int *err)
{
  struct simple_object_elf_attributes *to =
    (struct simple_object_elf_attributes *) todata;
  struct simple_object_elf_attributes *from =
    (struct simple_object_elf_attributes *) fromdata;

  if (to->ei_data != from->ei_data || to->ei_class != from->ei_class)
    {
      *err = 0;
      return "ELF object format mismatch";
    }

  if (to->machine != from->machine)
    {
      int ok;

      /* EM_SPARC and EM_SPARC32PLUS are compatible and force an
         output of EM_SPARC32PLUS.  */
      ok = 0;
      switch (to->machine)
        {
        case EM_SPARC:
          if (from->machine == EM_SPARC32PLUS)
            {
              to->machine = from->machine;
              ok = 1;
            }
          break;

        case EM_SPARC32PLUS:
          if (from->machine == EM_SPARC)
            ok = 1;
          break;

        default:
          break;
        }

      if (!ok)
        {
          *err = 0;
          return "ELF machine number mismatch";
        }
    }

  return NULL;
}

/* Release the private data for an attributes structure.  */

static void
simple_object_elf_release_attributes (void *data)
{
  XDELETE (data);
}

/* Prepare to write out a file.  */

static void *
simple_object_elf_start_write (void *attributes_data,
                               const char **errmsg ATTRIBUTE_UNUSED,
                               int *err ATTRIBUTE_UNUSED)
{
  struct simple_object_elf_attributes *attrs =
    (struct simple_object_elf_attributes *) attributes_data;
  struct simple_object_elf_write *ret;

  /* We're just going to record the attributes, but we need to make a
     copy because the user may delete them.  */
  ret = XNEW (struct simple_object_elf_write);
  ret->attrs = *attrs;
  ret->shdrs = NULL;
  return ret;
}

/* Write out an ELF ehdr.  */

static int
simple_object_elf_write_ehdr (simple_object_write *sobj, int descriptor,
                              const char **errmsg, int *err)
{
  struct simple_object_elf_attributes *attrs =
    (struct simple_object_elf_attributes *) sobj->data;
  const struct elf_type_functions* fns;
  unsigned char cl;
  size_t ehdr_size;
  unsigned char buf[sizeof (Elf64_External_Ehdr)];
  simple_object_write_section *section;
  unsigned int shnum;
  unsigned int shstrndx;

  fns = attrs->type_functions;
  cl = attrs->ei_class;

  shnum = 0;
  for (section = sobj->sections; section != NULL; section = section->next)
    ++shnum;
  if (shnum > 0)
    {
      /* Add a section header for the dummy section and one for
         .shstrtab.  */
      shnum += 2;
    }

  ehdr_size = (cl == ELFCLASS32
               ? sizeof (Elf32_External_Ehdr)
               : sizeof (Elf64_External_Ehdr));
  memset (buf, 0, sizeof (Elf64_External_Ehdr));

  buf[EI_MAG0] = ELFMAG0;
  buf[EI_MAG1] = ELFMAG1;
  buf[EI_MAG2] = ELFMAG2;
  buf[EI_MAG3] = ELFMAG3;
  buf[EI_CLASS] = cl;
  buf[EI_DATA] = attrs->ei_data;
  buf[EI_VERSION] = EV_CURRENT;
  buf[EI_OSABI] = attrs->ei_osabi;

  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_type, Elf_Half, ET_REL);
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_machine, Elf_Half, attrs->machine);
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_version, Elf_Word, EV_CURRENT);
  /* e_entry left as zero.  */
  /* e_phoff left as zero.  */
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shoff, Elf_Addr, ehdr_size);
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_flags, Elf_Word, attrs->flags);
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_ehsize, Elf_Half, ehdr_size);
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_phentsize, Elf_Half,
                 (cl == ELFCLASS32
                  ? sizeof (Elf32_External_Phdr)
                  : sizeof (Elf64_External_Phdr)));
  /* e_phnum left as zero.  */
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shentsize, Elf_Half,
                 (cl == ELFCLASS32
                  ? sizeof (Elf32_External_Shdr)
                  : sizeof (Elf64_External_Shdr)));
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shnum, Elf_Half,
                 shnum >= SHN_LORESERVE ? 0 : shnum);
  if (shnum == 0)
    shstrndx = 0;
  else
    {
      shstrndx = shnum - 1;
      if (shstrndx >= SHN_LORESERVE)
        shstrndx = SHN_XINDEX;
    }
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shstrndx, Elf_Half, shstrndx);

  return simple_object_internal_write (descriptor, 0, buf, ehdr_size,
                                       errmsg, err);
}

/* Write out an ELF shdr.  */

static int
simple_object_elf_write_shdr (simple_object_write *sobj, int descriptor,
                              off_t offset, unsigned int sh_name,
                              unsigned int sh_type, unsigned int sh_flags,
                              off_t sh_addr,
                              unsigned int sh_offset, unsigned int sh_size,
                              unsigned int sh_link, unsigned int sh_info,
                              size_t sh_addralign,
                              size_t sh_entsize,
                              const char **errmsg, int *err)
{
  struct simple_object_elf_attributes *attrs =
    (struct simple_object_elf_attributes *) sobj->data;
  const struct elf_type_functions* fns;
  unsigned char cl;
  size_t shdr_size;
  unsigned char buf[sizeof (Elf64_External_Shdr)];

  fns = attrs->type_functions;
  cl = attrs->ei_class;

  shdr_size = (cl == ELFCLASS32
               ? sizeof (Elf32_External_Shdr)
               : sizeof (Elf64_External_Shdr));
  memset (buf, 0, sizeof (Elf64_External_Shdr));

  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_name, Elf_Word, sh_name);
  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_type, Elf_Word, sh_type);
  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_flags, Elf_Addr, sh_flags);
  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_addr, Elf_Addr, sh_addr);
  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_offset, Elf_Addr, sh_offset);
  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_size, Elf_Addr, sh_size);
  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_link, Elf_Word, sh_link);
  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_info, Elf_Word, sh_info);
  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_addralign, Elf_Addr, sh_addralign);
  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_entsize, Elf_Addr, sh_entsize);

  return simple_object_internal_write (descriptor, offset, buf, shdr_size,
                                       errmsg, err);
}

/* Write out a complete ELF file.
   Ehdr
   initial dummy Shdr
   user-created Shdrs
   .shstrtab Shdr
   user-created section data
   .shstrtab data  */

static const char *
simple_object_elf_write_to_file (simple_object_write *sobj, int descriptor,
                                 int *err)
{
  struct simple_object_elf_write *eow =
    (struct simple_object_elf_write *) sobj->data;
  struct simple_object_elf_attributes *attrs = &eow->attrs;
  unsigned char cl;
  size_t ehdr_size;
  size_t shdr_size;
  const char *errmsg;
  simple_object_write_section *section;
  unsigned int shnum;
  size_t shdr_offset;
  size_t sh_offset;
  unsigned int first_sh_size;
  unsigned int first_sh_link;
  size_t sh_name;
  unsigned char zero;
  unsigned secnum;

  if (!simple_object_elf_write_ehdr (sobj, descriptor, &errmsg, err))
    return errmsg;

  cl = attrs->ei_class;
  if (cl == ELFCLASS32)
    {
      ehdr_size = sizeof (Elf32_External_Ehdr);
      shdr_size = sizeof (Elf32_External_Shdr);
    }
  else
    {
      ehdr_size = sizeof (Elf64_External_Ehdr);
      shdr_size = sizeof (Elf64_External_Shdr);
    }

  shnum = 0;
  for (section = sobj->sections; section != NULL; section = section->next)
    ++shnum;
  if (shnum == 0)
    return NULL;

  /* Add initial dummy Shdr and .shstrtab.  */
  shnum += 2;

  shdr_offset = ehdr_size;
  sh_offset = shdr_offset + shnum * shdr_size;

  if (shnum < SHN_LORESERVE)
    first_sh_size = 0;
  else
    first_sh_size = shnum;
  if (shnum - 1 < SHN_LORESERVE)
    first_sh_link = 0;
  else
    first_sh_link = shnum - 1;
  if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
                                     0, 0, 0, 0, 0, first_sh_size, first_sh_link,
                                     0, 0, 0, &errmsg, err))
    return errmsg;

  shdr_offset += shdr_size;

  sh_name = 1;
  secnum = 0;
  for (section = sobj->sections; section != NULL; section = section->next)
    {
      size_t mask;
      size_t new_sh_offset;
      size_t sh_size;
      struct simple_object_write_section_buffer *buffer;
      unsigned int sh_type = SHT_PROGBITS;
      unsigned int sh_flags = 0;
      off_t sh_addr = 0;
      unsigned int sh_link = 0;
      unsigned int sh_info = 0;
      size_t sh_addralign = 1U << section->align;
      size_t sh_entsize = 0;
      if (eow->shdrs)
        {
          sh_type = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
                                     eow->shdrs + secnum * shdr_size,
                                     sh_type, Elf_Word);
          sh_flags = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
                                      eow->shdrs + secnum * shdr_size,
                                      sh_flags, Elf_Addr);
          sh_addr = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
                                     eow->shdrs + secnum * shdr_size,
                                     sh_addr, Elf_Addr);
          sh_link = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
                                     eow->shdrs + secnum * shdr_size,
                                     sh_link, Elf_Word);
          sh_info = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
                                     eow->shdrs + secnum * shdr_size,
                                     sh_info, Elf_Word);
          sh_addralign = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
                                          eow->shdrs + secnum * shdr_size,
                                          sh_addralign, Elf_Addr);
          sh_entsize = ELF_FETCH_FIELD (attrs->type_functions, attrs->ei_class, Shdr,
                                        eow->shdrs + secnum * shdr_size,
                                        sh_entsize, Elf_Addr);
          secnum++;
        }

      mask = sh_addralign - 1;
      new_sh_offset = sh_offset + mask;
      new_sh_offset &= ~ mask;
      while (new_sh_offset > sh_offset)
        {
          unsigned char zeroes[16];
          size_t write;

          memset (zeroes, 0, sizeof zeroes);
          write = new_sh_offset - sh_offset;
          if (write > sizeof zeroes)
            write = sizeof zeroes;
          if (!simple_object_internal_write (descriptor, sh_offset, zeroes,
                                             write, &errmsg, err))
            return errmsg;
          sh_offset += write;
        }

      sh_size = 0;
      for (buffer = section->buffers; buffer != NULL; buffer = buffer->next)
        {
          if (!simple_object_internal_write (descriptor, sh_offset + sh_size,
                                             ((const unsigned char *)
                                              buffer->buffer),
                                             buffer->size, &errmsg, err))
            return errmsg;
          sh_size += buffer->size;
        }

      if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
                                         sh_name, sh_type, sh_flags,
                                         sh_addr, sh_offset,
                                         sh_size, sh_link, sh_info,
                                         sh_addralign, sh_entsize,
                                         &errmsg, err))
        return errmsg;

      shdr_offset += shdr_size;
      sh_name += strlen (section->name) + 1;
      sh_offset += sh_size;
    }

  if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
                                     sh_name, SHT_STRTAB, 0, 0, sh_offset,
                                     sh_name + strlen (".shstrtab") + 1, 0, 0,
                                     1, 0, &errmsg, err))
    return errmsg;

  /* .shstrtab has a leading zero byte.  */
  zero = 0;
  if (!simple_object_internal_write (descriptor, sh_offset, &zero, 1,
                                     &errmsg, err))
    return errmsg;
  ++sh_offset;

  for (section = sobj->sections; section != NULL; section = section->next)
    {
      size_t len;

      len = strlen (section->name) + 1;
      if (!simple_object_internal_write (descriptor, sh_offset,
                                         (const unsigned char *) section->name,
                                         len, &errmsg, err))
        return errmsg;
      sh_offset += len;
    }

  if (!simple_object_internal_write (descriptor, sh_offset,
                                     (const unsigned char *) ".shstrtab",
                                     strlen (".shstrtab") + 1, &errmsg, err))
    return errmsg;

  return NULL;
}

/* Release the private data for an simple_object_write structure.  */

static void
simple_object_elf_release_write (void *data)
{
  struct simple_object_elf_write *eow = (struct simple_object_elf_write *) data;
  if (eow->shdrs)
    XDELETE (eow->shdrs);
  XDELETE (data);
}

/* Copy all sections in an ELF file.  */

static const char *
simple_object_elf_copy_lto_debug_sections (simple_object_read *sobj,
                                           simple_object_write *dobj,
                                           char *(*pfn) (const char *),
                                           int *err)
{
  struct simple_object_elf_read *eor =
    (struct simple_object_elf_read *) sobj->data;
  const struct elf_type_functions *type_functions = eor->type_functions;
  struct simple_object_elf_write *eow =
    (struct simple_object_elf_write *) dobj->data;
  unsigned char ei_class = eor->ei_class;
  size_t shdr_size;
  unsigned int shnum;
  unsigned char *shdrs;
  const char *errmsg;
  unsigned char *shstrhdr;
  size_t name_size;
  off_t shstroff;
  unsigned char *names;
  unsigned int i;
  int changed;
  int *pfnret;
  const char **pfnname;
  unsigned new_i;
  unsigned *sh_map;
  unsigned first_shndx = 0;
  unsigned int *symtab_indices_shndx;

  shdr_size = (ei_class == ELFCLASS32
               ? sizeof (Elf32_External_Shdr)
               : sizeof (Elf64_External_Shdr));

  /* Read the section headers.  We skip section 0, which is not a
     useful section.  */

  shnum = eor->shnum;
  shdrs = XNEWVEC (unsigned char, shdr_size * (shnum - 1));

  if (!simple_object_internal_read (sobj->descriptor,
                                    sobj->offset + eor->shoff + shdr_size,
                                    shdrs,
                                    shdr_size * (shnum - 1),
                                    &errmsg, err))
    {
      XDELETEVEC (shdrs);
      return errmsg;
    }

  /* Read the section names.  */

  shstrhdr = shdrs + (eor->shstrndx - 1) * shdr_size;
  name_size = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                               shstrhdr, sh_size, Elf_Addr);
  shstroff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                              shstrhdr, sh_offset, Elf_Addr);
  names = XNEWVEC (unsigned char, name_size);
  if (!simple_object_internal_read (sobj->descriptor,
                                    sobj->offset + shstroff,
                                    names, name_size, &errmsg, err))
    {
      XDELETEVEC (names);
      XDELETEVEC (shdrs);
      return errmsg;
    }

  pfnret = XNEWVEC (int, shnum);
  pfnname = XNEWVEC (const char *, shnum);

  /* Map of symtab to index section.  */
  symtab_indices_shndx = XCNEWVEC (unsigned int, shnum - 1);

  /* First perform the callbacks to know which sections to preserve and
     what name to use for those.  */
  for (i = 1; i < shnum; ++i)
    {
      unsigned char *shdr;
      unsigned int sh_name, sh_type;
      const char *name;
      char *ret;

      shdr = shdrs + (i - 1) * shdr_size;
      sh_name = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                 shdr, sh_name, Elf_Word);
      if (sh_name >= name_size)
        {
          *err = 0;
          XDELETEVEC (names);
          XDELETEVEC (shdrs);
          return "ELF section name out of range";
        }

      name = (const char *) names + sh_name;

      ret = (*pfn) (name);
      pfnret[i - 1] = ret == NULL ? -1 : 0;
      pfnname[i - 1] = ret == NULL ? name : ret;
      if (first_shndx == 0
          && pfnret[i - 1] == 0)
        first_shndx = i;

      /* Remember the indexes of existing SHT_SYMTAB_SHNDX sections.  */
      sh_type = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                 shdr, sh_type, Elf_Word);
      if (sh_type == SHT_SYMTAB_SHNDX)
        {
          unsigned int sh_link;
          sh_link = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                     shdr, sh_link, Elf_Word);
          symtab_indices_shndx[sh_link - 1] = i;
          /* Always discard the extended index sections, after
             copying it will not be needed.  This way we don't need to
             update it and deal with the ordering constraints of
             processing the existing symtab and changing the index.  */
          pfnret[i - 1] = -1;
        }
    }

  /* Mark sections as preserved that are required by to be preserved
     sections.  */
  do
    {
      changed = 0;
      for (i = 1; i < shnum; ++i)
        {
          unsigned char *shdr;
          unsigned int sh_type, sh_info, sh_link;
          off_t offset;
          off_t length;

          shdr = shdrs + (i - 1) * shdr_size;
          sh_type = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                     shdr, sh_type, Elf_Word);
          sh_info = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                     shdr, sh_info, Elf_Word);
          sh_link = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                     shdr, sh_link, Elf_Word);
          if (sh_type == SHT_GROUP)
            {
              /* Mark groups containing copied sections.  */
              unsigned entsize = ELF_FETCH_FIELD (type_functions, ei_class,
                                                  Shdr, shdr, sh_entsize,
                                                  Elf_Addr);
              unsigned char *ent, *buf;
              int keep = 0;
              offset = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                        shdr, sh_offset, Elf_Addr);
              length = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                        shdr, sh_size, Elf_Addr);
              buf = XNEWVEC (unsigned char, length);
              if (!simple_object_internal_read (sobj->descriptor,
                                                sobj->offset + offset, buf,
                                                (size_t) length, &errmsg, err))
                {
                  XDELETEVEC (buf);
                  XDELETEVEC (names);
                  XDELETEVEC (shdrs);
                  return errmsg;
                }
              for (ent = buf + entsize; ent < buf + length; ent += entsize)
                {
                  unsigned sec = type_functions->fetch_Elf_Word (ent);
                  if (pfnret[sec - 1] == 0)
                    keep = 1;
                }
              if (keep)
                {
                  changed |= (pfnret[sh_link - 1] == -1
                              || pfnret[i - 1] == -1);
                  pfnret[sh_link - 1] = 0;
                  pfnret[i - 1] = 0;
                }
            }
          if (sh_type == SHT_RELA
              || sh_type == SHT_REL)
            {
              /* Mark relocation sections and symtab of copied sections.  */
              if (pfnret[sh_info - 1] == 0)
                {
                  changed |= (pfnret[sh_link - 1] == -1
                              || pfnret[i - 1] == -1);
                  pfnret[sh_link - 1] = 0;
                  pfnret[i - 1] = 0;
                }
            }
          if (sh_type == SHT_SYMTAB)
            {
              /* Mark strings sections of copied symtabs.  */
              if (pfnret[i - 1] == 0)
                {
                  changed |= pfnret[sh_link - 1] == -1;
                  pfnret[sh_link - 1] = 0;
                }
            }
        }
    }
  while (changed);

  /* Compute a mapping of old -> new section numbers.  */
  sh_map = XNEWVEC (unsigned, shnum);
  sh_map[0] = 0;
  new_i = 1;
  for (i = 1; i < shnum; ++i)
    {
      if (pfnret[i - 1] == -1)
        sh_map[i] = 0;
      else
        sh_map[i] = new_i++;
    }
  if (new_i - 1 >= SHN_LORESERVE)
    {
      *err = ENOTSUP;
      return "Too many copied sections";
    }
  eow->shdrs = XNEWVEC (unsigned char, shdr_size * (new_i - 1));

  /* Then perform the actual copying.  */
  new_i = 0;
  for (i = 1; i < shnum; ++i)
    {
      unsigned char *shdr;
      unsigned int sh_name, sh_type;
      const char *name;
      off_t offset;
      off_t length;
      simple_object_write_section *dest;
      off_t flags;
      unsigned char *buf;

      if (pfnret[i - 1])
        continue;

      new_i++;
      shdr = shdrs + (i - 1) * shdr_size;
      sh_name = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                 shdr, sh_name, Elf_Word);
      if (sh_name >= name_size)
        {
          *err = 0;
          XDELETEVEC (names);
          XDELETEVEC (shdrs);
          XDELETEVEC (symtab_indices_shndx);
          return "ELF section name out of range";
        }

      name = pfnname[i - 1];
      offset = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                shdr, sh_offset, Elf_Addr);
      length = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                shdr, sh_size, Elf_Addr);
      sh_type = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                 shdr, sh_type, Elf_Word);

      dest = simple_object_write_create_section (dobj, pfnname[i - 1],
                                                 0, &errmsg, err);
      if (dest == NULL)
        {
          XDELETEVEC (names);
          XDELETEVEC (shdrs);
          XDELETEVEC (symtab_indices_shndx);
          return errmsg;
        }

      /* Record the SHDR of the source.  */
      memcpy (eow->shdrs + (new_i - 1) * shdr_size, shdr, shdr_size);
      shdr = eow->shdrs + (new_i - 1) * shdr_size;

      /* Copy the data.
         ???  This is quite wasteful and ideally would be delayed until
         write_to_file ().  Thus it questions the interfacing
         which eventually should contain destination creation plus
         writing.  */
      buf = XNEWVEC (unsigned char, length);
      if (!simple_object_internal_read (sobj->descriptor,
                                        sobj->offset + offset, buf,
                                        (size_t) length, &errmsg, err))
        {
          XDELETEVEC (buf);
          XDELETEVEC (names);
          XDELETEVEC (shdrs);
          XDELETEVEC (symtab_indices_shndx);
          return errmsg;
        }

      /* If we are processing .symtab purge __gnu_lto_v1 and
         __gnu_lto_slim symbols from it and any symbols in discarded
         sections.  */
      if (sh_type == SHT_SYMTAB)
        {
          unsigned entsize = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                              shdr, sh_entsize, Elf_Addr);
          unsigned strtab = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                             shdr, sh_link, Elf_Word);
          unsigned char *strshdr = shdrs + (strtab - 1) * shdr_size;
          off_t stroff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                          strshdr, sh_offset, Elf_Addr);
          size_t strsz = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                          strshdr, sh_size, Elf_Addr);
          char *strings = XNEWVEC (char, strsz);
          char *gnu_lto = strings;
          unsigned char *ent;
          unsigned *shndx_table = NULL;
          simple_object_internal_read (sobj->descriptor,
                                       sobj->offset + stroff,
                                       (unsigned char *)strings,
                                       strsz, &errmsg, err);
          /* Find gnu_lto_ in strings.  */
          while ((gnu_lto = (char *) memchr (gnu_lto, 'g',
                                             strings + strsz - gnu_lto)))
            if (strncmp (gnu_lto, "gnu_lto_v1",
                         strings + strsz - gnu_lto) == 0)
              break;
            else
              gnu_lto++;
          /* Read the section index table if present.  */
          if (symtab_indices_shndx[i - 1] != 0)
            {
              unsigned char *sidxhdr = shdrs + (strtab - 1) * shdr_size;
              off_t sidxoff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                               sidxhdr, sh_offset, Elf_Addr);
              size_t sidxsz = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                               sidxhdr, sh_size, Elf_Addr);
              shndx_table = (unsigned *)XNEWVEC (char, sidxsz);
              simple_object_internal_read (sobj->descriptor,
                                           sobj->offset + sidxoff,
                                           (unsigned char *)shndx_table,
                                           sidxsz, &errmsg, err);
            }
          for (ent = buf; ent < buf + length; ent += entsize)
            {
              unsigned st_shndx = ELF_FETCH_FIELD (type_functions, ei_class,
                                                   Sym, ent,
                                                   st_shndx, Elf_Half);
              unsigned raw_st_shndx = st_shndx;
              unsigned char *st_info;
              unsigned char *st_other;
              int discard = 0;
              if (ei_class == ELFCLASS32)
                {
                  st_info = &((Elf32_External_Sym *)ent)->st_info;
                  st_other = &((Elf32_External_Sym *)ent)->st_other;
                }
              else
                {
                  st_info = &((Elf64_External_Sym *)ent)->st_info;
                  st_other = &((Elf64_External_Sym *)ent)->st_other;
                }
              if (st_shndx == SHN_XINDEX)
                st_shndx = type_functions->fetch_Elf_Word
                    ((unsigned char *)(shndx_table + (ent - buf) / entsize));
              /* Eliminate all COMMONs - this includes __gnu_lto_v1
                 and __gnu_lto_slim which otherwise cause endless
                 LTO plugin invocation.  */
              if (st_shndx == SHN_COMMON)
                discard = 1;
              /* We also need to remove symbols refering to sections
                 we'll eventually remove as with fat LTO objects
                 we otherwise get duplicate symbols at final link
                 (with GNU ld, gold is fine and ignores symbols in
                 sections marked as EXCLUDE).  ld/20513  */
              else if (st_shndx != SHN_UNDEF
                       && st_shndx < shnum
                       && pfnret[st_shndx - 1] == -1)
                discard = 1;

              if (discard)
                {
                  /* Make discarded symbols undefined and unnamed
                     in case it is local.  */
                  int bind = ELF_ST_BIND (*st_info);
                  int other = STV_DEFAULT;
                  if (bind == STB_LOCAL)
                    {
                      /* Make discarded local symbols unnamed and
                         defined in the first prevailing section.  */
                      ELF_SET_FIELD (type_functions, ei_class, Sym,
                                     ent, st_name, Elf_Word, 0);
                      ELF_SET_FIELD (type_functions, ei_class, Sym,
                                     ent, st_shndx, Elf_Half,
                                     sh_map[first_shndx]);
                    }
                  else
                    {
                      /* Make discarded global symbols hidden weak
                         undefined and sharing the gnu_lto_ name.  */
                      bind = STB_WEAK;
                      other = STV_HIDDEN;
                      if (gnu_lto)
                        ELF_SET_FIELD (type_functions, ei_class, Sym,
                                       ent, st_name, Elf_Word,
                                       gnu_lto - strings);
                      ELF_SET_FIELD (type_functions, ei_class, Sym,
                                     ent, st_shndx, Elf_Half, SHN_UNDEF);
                    }
                  *st_other = other;
                  *st_info = ELF_ST_INFO (bind, STT_NOTYPE);
                  ELF_SET_FIELD (type_functions, ei_class, Sym,
                                 ent, st_value, Elf_Addr, 0);
                  ELF_SET_FIELD (type_functions, ei_class, Sym,
                                 ent, st_size, Elf_Word, 0);
                }
              else if (raw_st_shndx < SHN_LORESERVE
                       || raw_st_shndx == SHN_XINDEX)
                /* Remap the section reference.  */
                ELF_SET_FIELD (type_functions, ei_class, Sym,
                               ent, st_shndx, Elf_Half, sh_map[st_shndx]);
            }
          XDELETEVEC (strings);
          XDELETEVEC (shndx_table);
        }
      else if (sh_type == SHT_GROUP)
        {
          /* Remap section indices in groups and remove removed members.  */
          unsigned char *ent, *dst;
          for (dst = ent = buf + 4; ent < buf + length; ent += 4)
            {
              unsigned shndx = type_functions->fetch_Elf_Word (ent);
              if (pfnret[shndx - 1] == -1)
                ;
              else
                {
                  type_functions->set_Elf_Word (dst, sh_map[shndx]);
                  dst += 4;
                }
            }
          /* Adjust the length.  */
          length = dst - buf;
        }

      errmsg = simple_object_write_add_data (dobj, dest,
                                             buf, length, 1, err);
      XDELETEVEC (buf);
      if (errmsg)
        {
          XDELETEVEC (names);
          XDELETEVEC (shdrs);
          XDELETEVEC (symtab_indices_shndx);
          return errmsg;
        }

      flags = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                               shdr, sh_flags, Elf_Addr);
      /* Remap the section references.  */
      {
        unsigned int sh_info, sh_link;
        if (flags & SHF_INFO_LINK || sh_type == SHT_REL || sh_type == SHT_RELA)
          {
            sh_info = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                       shdr, sh_info, Elf_Word);
            if (sh_info < SHN_LORESERVE
                || sh_info > SHN_HIRESERVE)
              sh_info = sh_map[sh_info];
            ELF_SET_FIELD (type_functions, ei_class, Shdr,
                           shdr, sh_info, Elf_Word, sh_info);
          }
        sh_link = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
                                   shdr, sh_link, Elf_Word);
        if (sh_link < SHN_LORESERVE
            || sh_link > SHN_HIRESERVE)
          sh_link = sh_map[sh_link];
        ELF_SET_FIELD (type_functions, ei_class, Shdr,
                       shdr, sh_link, Elf_Word, sh_link);
      }
      /* The debugobj doesn't contain any code, thus no trampolines.
         Even when the original object needs trampolines, debugobj
         doesn't.  */
      if (strcmp (name, ".note.GNU-stack") == 0)
        flags &= ~SHF_EXECINSTR;
      /* Clear SHF_EXCLUDE on to be preserved sections.  */
      flags &= ~SHF_EXCLUDE;
      ELF_SET_FIELD (type_functions, ei_class, Shdr,
                     shdr, sh_flags, Elf_Addr, flags);
    }

  XDELETEVEC (names);
  XDELETEVEC (shdrs);
  XDELETEVEC (pfnret);
  XDELETEVEC (pfnname);
  XDELETEVEC (symtab_indices_shndx);
  XDELETEVEC (sh_map);

  return NULL;
}


/* The ELF functions.  */

const struct simple_object_functions simple_object_elf_functions =
{
  simple_object_elf_match,
  simple_object_elf_find_sections,
  simple_object_elf_fetch_attributes,
  simple_object_elf_release_read,
  simple_object_elf_attributes_merge,
  simple_object_elf_release_attributes,
  simple_object_elf_start_write,
  simple_object_elf_write_to_file,
  simple_object_elf_release_write,
  simple_object_elf_copy_lto_debug_sections
};