PR libstdc++/80041 fix codecvt_utf16<wchar_t> to use UTF-16 not UTF-8

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

/* simple-object-coff.c -- routines to manipulate XCOFF object files.
   Copyright (C) 2013-2017 Free Software Foundation, Inc.
   Written by Ian Lance Taylor, Google and David Edelsohn, IBM.

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>
#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"

/* XCOFF structures and constants.  */

/* XCOFF file header.  */

struct external_filehdr
{
  unsigned char f_magic[2];     /* magic number                 */
  unsigned char f_nscns[2];     /* number of sections           */
  unsigned char f_timdat[4];    /* time & date stamp            */
  union
  {
    struct
    {
      unsigned char f_symptr[4];        /* file pointer to symtab       */
      unsigned char f_nsyms[4]; /* number of symtab entries     */
      unsigned char f_opthdr[2];        /* sizeof(optional hdr)         */
      unsigned char f_flags[2]; /* flags                        */
    } xcoff32;
    struct
    {
      unsigned char f_symptr[8];        /* file pointer to symtab       */
      unsigned char f_opthdr[2];        /* sizeof(optional hdr)         */
      unsigned char f_flags[2]; /* flags                        */
      unsigned char f_nsyms[4]; /* number of symtab entries     */
    } xcoff64;
  } u;
};

/* Bits for filehdr f_flags field.  */

#define F_EXEC                  (0x0002)

/* The known values of f_magic in an XCOFF file header.  */

#define U802WRMAGIC 0730        /* Writeable text segments.  */
#define U802ROMAGIC 0735        /* Readonly sharable text segments.  */
#define U802TOCMAGIC 0737       /* Readonly text segments and TOC.  */
#define U803XTOCMAGIC 0757      /* Aix 4.3 64-bit XCOFF.  */
#define U64_TOCMAGIC 0767       /* AIX 5+ 64-bit XCOFF.  */

/* XCOFF section header.  */

struct external_scnhdr
{
  unsigned char s_name[8];      /* section name                         */
  union
  {
    struct
    {
      unsigned char s_paddr[4]; /* physical address, aliased s_nlib     */
      unsigned char s_vaddr[4]; /* virtual address                      */
      unsigned char s_size[4];  /* section size                         */
      unsigned char s_scnptr[4];        /* file ptr to raw data for section */
      unsigned char s_relptr[4];        /* file ptr to relocation       */
      unsigned char s_lnnoptr[4];       /* file ptr to line numbers     */
      unsigned char s_nreloc[2];        /* number of relocation entries */
      unsigned char s_nlnno[2]; /* number of line number entries        */
      unsigned char s_flags[4]; /* flags                                */
    } xcoff32;
    struct
    {
      unsigned char s_paddr[8]; /* physical address, aliased s_nlib     */
      unsigned char s_vaddr[8]; /* virtual address                      */
      unsigned char s_size[8];  /* section size                         */
      unsigned char s_scnptr[8];        /* file ptr to raw data for section */
      unsigned char s_relptr[8];        /* file ptr to relocation       */
      unsigned char s_lnnoptr[8];       /* file ptr to line numbers     */
      unsigned char s_nreloc[4];        /* number of relocation entries */
      unsigned char s_nlnno[4]; /* number of line number entries        */
      unsigned char s_flags[4]; /* flags                                */
    } xcoff64;
  } u;
};

#define SCNHSZ32        (40)
#define SCNHSZ64        (68)

/* The length of the s_name field in struct external_scnhdr.  */

#define SCNNMLEN        (8)

/* Bits for scnhdr s_flags field.  */

#define STYP_DATA                       0x40

/* XCOFF symbol table entry.  */


#define N_SYMNMLEN      (8)     /* # characters in a symbol name        */

/* The format of an XCOFF symbol-table entry.  */
struct external_syment
{
  union {
    struct {
      union {
        /* The name of the symbol.  There is an implicit null character
           after the end of the array.  */
        char n_name[N_SYMNMLEN];
        struct {
          /* If n_zeroes is zero, n_offset is the offset the name from
             the start of the string table.  */
          unsigned char n_zeroes[4];
          unsigned char n_offset[4];
        } n;
      } n;

      /* The symbol's value.  */
      unsigned char n_value[4];
    } xcoff32;
    struct {
      /* The symbol's value.  */
      unsigned char n_value[8];

      /* The offset of the symbol from the start of the string table.  */
      unsigned char n_offset[4];
    } xcoff64;
  } u;

  /* The number of the section to which this symbol belongs.  */
  unsigned char n_scnum[2];

  /* The type of symbol.  (It can be interpreted as an n_lang
     and an n_cpu byte, but we don't care about that here.)  */
  unsigned char n_type[2];

  /* The class of symbol (a C_* value).  */
  unsigned char n_sclass[1];

  /* The number of auxiliary symbols attached to this entry.  */
  unsigned char n_numaux[1];
};

#define SYMESZ          (18)

/* Length allowed for filename in aux sym format 4.  */

#define FILNMLEN        (14)

/* Omits x_sym and other unused variants.  */

union external_auxent
{
  /* Aux sym format 4: file.  */
  union
  {
    char x_fname[FILNMLEN];
    struct
    {
      unsigned char x_zeroes[4];
      unsigned char x_offset[4];
      unsigned char x_pad[FILNMLEN-8];
      unsigned char x_ftype;
    } _x;
  } x_file;
  /* Aux sym format 5: section.  */
  struct
  {
    unsigned char x_scnlen[4];          /* section length               */
    unsigned char x_nreloc[2];          /* # relocation entries         */
    unsigned char x_nlinno[2];          /* # line numbers               */
  } x_scn;
  /* CSECT auxiliary entry.  */
  union
  {
    struct
    {
      struct
      {
        unsigned char x_scnlen[4];      /* csect length */
        unsigned char x_parmhash[4];    /* parm type hash index */
        unsigned char x_snhash[2];      /* sect num with parm hash */
        unsigned char x_smtyp;          /* symbol align and type */
        unsigned char x_smclas;         /* storage mapping class */
        unsigned char x_stab;           /* dbx stab info index */
        unsigned char x_snstab[2];      /* sect num with dbx stab */
      } x_csect;
    } xcoff32;
    struct
    {
      struct
      {
        unsigned char x_scnlen_lo[4];   /* csect length */
        unsigned char x_parmhash[4];    /* parm type hash index */
        unsigned char x_snhash[2];      /* sect num with parm hash */
        unsigned char x_smtyp;          /* symbol align and type */
        unsigned char x_smclas;         /* storage mapping class */
        unsigned char x_scnlen_hi[4];
        unsigned char pad;
        unsigned char x_auxtype;
      } x_csect;
    } xcoff64;
  } u;
  /* SECTION/DWARF auxiliary entry.  */
  struct
  {
    unsigned char x_scnlen[4];          /* section length */
    unsigned char pad1[4];
    unsigned char x_nreloc[4];          /* number RLDs */
  } x_sect;
};

/* Symbol-related constants.  */

#define N_DEBUG         (-2)
#define IMAGE_SYM_TYPE_NULL     (0)
#define IMAGE_SYM_DTYPE_NULL    (0)
#define IMAGE_SYM_CLASS_STATIC  (3)
#define IMAGE_SYM_CLASS_FILE    (103)

#define IMAGE_SYM_TYPE \
  ((IMAGE_SYM_DTYPE_NULL << 4) | IMAGE_SYM_TYPE_NULL)

#define C_STAT          (3)
#define C_FILE          (103)

/* Private data for an simple_object_read.  */

struct simple_object_xcoff_read
{
  /* Magic number.  */
  unsigned short magic;
  /* Number of sections.  */
  unsigned short nscns;
  /* File offset of symbol table.  */
  off_t symptr;
  /* Number of symbol table entries.  */
  unsigned int nsyms;
  /* Flags.  */
  unsigned short flags;
  /* Offset of section headers in file.  */
  off_t scnhdr_offset;
};

/* Private data for an simple_object_attributes.  */

struct simple_object_xcoff_attributes
{
  /* Magic number.  */
  unsigned short magic;
  /* Flags.  */
  unsigned short flags;
};

/* See if we have a XCOFF file.  */

static void *
simple_object_xcoff_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 short magic;
  unsigned short (*fetch_16) (const unsigned char *);
  unsigned int (*fetch_32) (const unsigned char *);
  ulong_type (*fetch_64) (const unsigned char *);
  unsigned char hdrbuf[sizeof (struct external_filehdr)];
  struct simple_object_xcoff_read *ocr;
  int u64;

  magic = simple_object_fetch_big_16 (header);

  if (magic != U802TOCMAGIC && magic != U64_TOCMAGIC)
    {
      *errmsg = NULL;
      *err = 0;
      return NULL;
    }

  fetch_16 = simple_object_fetch_big_16;
  fetch_32 = simple_object_fetch_big_32;
  fetch_64 = simple_object_fetch_big_64;

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

  u64 = magic == U64_TOCMAGIC;

  ocr = XNEW (struct simple_object_xcoff_read);
  ocr->magic = magic;
  ocr->nscns = fetch_16 (hdrbuf + offsetof (struct external_filehdr, f_nscns));
  if (u64)
    {
      ocr->symptr = fetch_64 (hdrbuf
                              + offsetof (struct external_filehdr,
                                          u.xcoff64.f_symptr));
      ocr->nsyms = fetch_32 (hdrbuf + offsetof (struct external_filehdr,
                                                u.xcoff64.f_nsyms));
      ocr->scnhdr_offset = (sizeof (struct external_filehdr)
                            + fetch_16 (hdrbuf + offsetof (struct external_filehdr,
                                                           u.xcoff64.f_opthdr)));

    }
  else
    {
      ocr->symptr = fetch_32 (hdrbuf
                              + offsetof (struct external_filehdr,
                                          u.xcoff32.f_symptr));
      ocr->nsyms = fetch_32 (hdrbuf + offsetof (struct external_filehdr,
                                                u.xcoff32.f_nsyms));
      ocr->scnhdr_offset = (sizeof (struct external_filehdr) - 4
                            + fetch_16 (hdrbuf + offsetof (struct external_filehdr,
                                                           u.xcoff32.f_opthdr)));

    }

  return (void *) ocr;
}

/* Read the string table in a XCOFF file.  */

static char *
simple_object_xcoff_read_strtab (simple_object_read *sobj, size_t *strtab_size,
                                 const char **errmsg, int *err)
{
  struct simple_object_xcoff_read *ocr =
    (struct simple_object_xcoff_read *) sobj->data;
  off_t strtab_offset;
  unsigned char strsizebuf[4];
  size_t strsize;
  char *strtab;

  strtab_offset = sobj->offset + ocr->symptr
    + ocr->nsyms * SYMESZ;
  if (!simple_object_internal_read (sobj->descriptor, strtab_offset,
                                    strsizebuf, 4, errmsg, err))
    return NULL;
  strsize = simple_object_fetch_big_32 (strsizebuf);
  strtab = XNEWVEC (char, strsize);
  if (!simple_object_internal_read (sobj->descriptor, strtab_offset,
                                    (unsigned char *) strtab, strsize, errmsg,
                                    err))
    {
      XDELETEVEC (strtab);
      return NULL;
    }
  *strtab_size = strsize;
  return strtab;
}

/* Find all sections in a XCOFF file.  */

static const char *
simple_object_xcoff_find_sections (simple_object_read *sobj,
                                  int (*pfn) (void *, const char *,
                                              off_t offset, off_t length),
                                  void *data,
                                  int *err)
{
  struct simple_object_xcoff_read *ocr =
    (struct simple_object_xcoff_read *) sobj->data;
  int u64 = ocr->magic == U64_TOCMAGIC;
  size_t scnhdr_size;
  unsigned char *scnbuf;
  const char *errmsg;
  unsigned int (*fetch_32) (const unsigned char *);
  ulong_type (*fetch_64) (const unsigned char *);
  unsigned int nscns;
  char *strtab;
  size_t strtab_size;
  unsigned int i;

  scnhdr_size = u64 ? SCNHSZ64 : SCNHSZ32;
  scnbuf = XNEWVEC (unsigned char, scnhdr_size * ocr->nscns);
  if (!simple_object_internal_read (sobj->descriptor,
                                    sobj->offset + ocr->scnhdr_offset,
                                    scnbuf, scnhdr_size * ocr->nscns, &errmsg,
                                    err))
    {
      XDELETEVEC (scnbuf);
      return errmsg;
    }

  fetch_32 = simple_object_fetch_big_32;
  fetch_64 = simple_object_fetch_big_64;

  nscns = ocr->nscns;
  strtab = NULL;
  strtab_size = 0;
  for (i = 0; i < nscns; ++i)
    {
      unsigned char *scnhdr;
      unsigned char *scnname;
      char namebuf[SCNNMLEN + 1];
      char *name;
      off_t scnptr;
      unsigned int size;

      scnhdr = scnbuf + i * scnhdr_size;
      scnname = scnhdr + offsetof (struct external_scnhdr, s_name);
      memcpy (namebuf, scnname, SCNNMLEN);
      namebuf[SCNNMLEN] = '\0';
      name = &namebuf[0];
      if (namebuf[0] == '/')
        {
          size_t strindex;
          char *end;

          strindex = strtol (namebuf + 1, &end, 10);
          if (*end == '\0')
            {
              /* The real section name is found in the string
                 table.  */
              if (strtab == NULL)
                {
                  strtab = simple_object_xcoff_read_strtab (sobj,
                                                           &strtab_size,
                                                           &errmsg, err);
                  if (strtab == NULL)
                    {
                      XDELETEVEC (scnbuf);
                      return errmsg;
                    }
                }

              if (strindex < 4 || strindex >= strtab_size)
                {
                  XDELETEVEC (strtab);
                  XDELETEVEC (scnbuf);
                  *err = 0;
                  return "section string index out of range";
                }

              name = strtab + strindex;
            }
        }

      if (u64)
        {
          scnptr = fetch_64 (scnhdr + offsetof (struct external_scnhdr,
                                                u.xcoff64.s_scnptr));
          size = fetch_64 (scnhdr + offsetof (struct external_scnhdr,
                                              u.xcoff64.s_size));
        }
      else
        {
          scnptr = fetch_32 (scnhdr + offsetof (struct external_scnhdr,
                                                u.xcoff32.s_scnptr));
          size = fetch_32 (scnhdr + offsetof (struct external_scnhdr,
                                              u.xcoff32.s_size));
        }

      if (!(*pfn) (data, name, scnptr, size))
        break;
    }

  if (strtab != NULL)
    XDELETEVEC (strtab);
  XDELETEVEC (scnbuf);

  return NULL;
}

/* Fetch the attributes for an simple_object_read.  */

static void *
simple_object_xcoff_fetch_attributes (simple_object_read *sobj,
                                     const char **errmsg ATTRIBUTE_UNUSED,
                                     int *err ATTRIBUTE_UNUSED)
{
  struct simple_object_xcoff_read *ocr =
    (struct simple_object_xcoff_read *) sobj->data;
  struct simple_object_xcoff_attributes *ret;

  ret = XNEW (struct simple_object_xcoff_attributes);
  ret->magic = ocr->magic;
  ret->flags = ocr->flags;
  return ret;
}

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

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

/* Compare two attributes structures.  */

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

  if (to->magic != from->magic)
    {
      *err = 0;
      return "XCOFF object format mismatch";
    }
  return NULL;
}

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

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

/* Prepare to write out a file.  */

static void *
simple_object_xcoff_start_write (void *attributes_data,
                                const char **errmsg ATTRIBUTE_UNUSED,
                                int *err ATTRIBUTE_UNUSED)
{
  struct simple_object_xcoff_attributes *attrs =
    (struct simple_object_xcoff_attributes *) attributes_data;
  struct simple_object_xcoff_attributes *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_xcoff_attributes);
  *ret = *attrs;
  return ret;
}

/* Write out a XCOFF filehdr.  */

static int
simple_object_xcoff_write_filehdr (simple_object_write *sobj, int descriptor,
                                  unsigned int nscns, size_t symtab_offset,
                                  unsigned int nsyms, const char **errmsg,
                                  int *err)
{
  struct simple_object_xcoff_attributes *attrs =
    (struct simple_object_xcoff_attributes *) sobj->data;
  int u64 = attrs->magic == U64_TOCMAGIC;
  unsigned char hdrbuf[sizeof (struct external_filehdr)];
  unsigned char *hdr;
  void (*set_16) (unsigned char *, unsigned short);
  void (*set_32) (unsigned char *, unsigned int);
  void (*set_64) (unsigned char *, ulong_type);

  hdr = &hdrbuf[0];

  set_16 = simple_object_set_big_16;
  set_32 = simple_object_set_big_32;
  set_64 = simple_object_set_big_64;

  memset (hdr, 0, sizeof (struct external_filehdr));

  set_16 (hdr + offsetof (struct external_filehdr, f_magic), attrs->magic);
  set_16 (hdr + offsetof (struct external_filehdr, f_nscns), nscns);
  /* f_timdat left as zero.  */
  if (u64)
    {
      set_64 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_symptr),
              symtab_offset);
      set_32 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_nsyms),
              nsyms);
      /* f_opthdr left as zero.  */
      set_16 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_flags),
              attrs->flags);
    }
  else
    {
      set_32 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_symptr),
              symtab_offset);
      set_32 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_nsyms),
              nsyms);
      /* f_opthdr left as zero.  */
      set_16 (hdr + offsetof (struct external_filehdr, u.xcoff64.f_flags),
              attrs->flags);
    }

  return simple_object_internal_write (descriptor, 0, hdrbuf,
                                       sizeof (struct external_filehdr),
                                       errmsg, err);
}

/* Write out a XCOFF section header.  */

static int
simple_object_xcoff_write_scnhdr (simple_object_write *sobj,
                                  int descriptor,
                                  const char *name, size_t *name_offset,
                                  off_t scnhdr_offset, size_t scnsize,
                                  off_t offset, unsigned int align,
                                  const char **errmsg, int *err)
{
  struct simple_object_xcoff_read *ocr =
    (struct simple_object_xcoff_read *) sobj->data;
  int u64 = ocr->magic == U64_TOCMAGIC;
  void (*set_32) (unsigned char *, unsigned int);
  void (*set_64) (unsigned char *, unsigned int);
  unsigned char hdrbuf[sizeof (struct external_scnhdr)];
  unsigned char *hdr;
  size_t namelen;
  unsigned int flags;

  set_32 = simple_object_set_big_32;
  set_64 = simple_object_set_big_32;

  memset (hdrbuf, 0, sizeof hdrbuf);
  hdr = &hdrbuf[0];

  namelen = strlen (name);
  if (namelen <= SCNNMLEN)
    strncpy ((char *) hdr + offsetof (struct external_scnhdr, s_name),
             name, SCNNMLEN);
  else
    {
      snprintf ((char *) hdr + offsetof (struct external_scnhdr, s_name),
                SCNNMLEN, "/%lu", (unsigned long) *name_offset);
      *name_offset += namelen + 1;
    }

  /* s_paddr left as zero.  */
  /* s_vaddr left as zero.  */
  if (u64)
    {
      set_64 (hdr + offsetof (struct external_scnhdr, u.xcoff64.s_size),
              scnsize);
      set_64 (hdr + offsetof (struct external_scnhdr, u.xcoff64.s_scnptr),
              offset);
    }
  else
    {
      set_32 (hdr + offsetof (struct external_scnhdr, u.xcoff32.s_size),
              scnsize);
      set_32 (hdr + offsetof (struct external_scnhdr, u.xcoff32.s_scnptr),
              offset);
    }
  /* s_relptr left as zero.  */
  /* s_lnnoptr left as zero.  */
  /* s_nreloc left as zero.  */
  /* s_nlnno left as zero.  */
  flags = STYP_DATA;
  if (align > 13)
    align = 13;
  if (u64)
    set_32 (hdr + offsetof (struct external_scnhdr, u.xcoff64.s_flags), flags);
  else
    set_32 (hdr + offsetof (struct external_scnhdr, u.xcoff32.s_flags), flags);

  return simple_object_internal_write (descriptor, scnhdr_offset, hdrbuf,
                                       u64 ? SCNHSZ64 : SCNHSZ32,
                                       errmsg, err);
}

/* Write out a complete XCOFF file.  */

static const char *
simple_object_xcoff_write_to_file (simple_object_write *sobj, int descriptor,
                                  int *err)
{
  struct simple_object_xcoff_read *ocr =
    (struct simple_object_xcoff_read *) sobj->data;
  int u64 = ocr->magic == U64_TOCMAGIC;
  unsigned int nscns, secnum;
  simple_object_write_section *section;
  off_t scnhdr_offset;
  size_t symtab_offset;
  off_t secsym_offset;
  unsigned int nsyms;
  size_t offset;
  size_t name_offset;
  const char *errmsg;
  unsigned char strsizebuf[4];
  /* The interface doesn't give us access to the name of the input file
     yet.  We want to use its basename for the FILE symbol.  This is
     what 'gas' uses when told to assemble from stdin.  */
  const char *source_filename = "fake";
  size_t sflen;
  union
  {
    struct external_syment sym;
    union external_auxent aux;
  } syms[2];
  void (*set_16) (unsigned char *, unsigned short);
  void (*set_32) (unsigned char *, unsigned int);

  set_16 = simple_object_set_big_16;
  set_32 = simple_object_set_big_32;

  nscns = 0;
  for (section = sobj->sections; section != NULL; section = section->next)
    ++nscns;

  scnhdr_offset = sizeof (struct external_filehdr) - (u64 ? 4 : 0);
  offset = scnhdr_offset + nscns * (u64 ? SCNHSZ64 : SCNHSZ32);
  name_offset = 4;
  for (section = sobj->sections; section != NULL; section = section->next)
    {
      size_t mask;
      size_t new_offset;
      size_t scnsize;
      struct simple_object_write_section_buffer *buffer;

      mask = (1U << section->align) - 1;
      new_offset = offset & mask;
      new_offset &= ~ mask;
      while (new_offset > offset)
        {
          unsigned char zeroes[16];
          size_t write;

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

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

      if (!simple_object_xcoff_write_scnhdr (sobj, descriptor, section->name,
                                            &name_offset, scnhdr_offset,
                                            scnsize, offset, section->align,
                                            &errmsg, err))
        return errmsg;

      scnhdr_offset += u64 ? SCNHSZ64 : SCNHSZ32;
      offset += scnsize;
    }

  /* Symbol table is always half-word aligned.  */
  offset += (offset & 1);
  /* There is a file symbol and a section symbol per section,
     and each of these has a single auxiliary symbol following.  */
  nsyms = 2 * (nscns + 1);
  symtab_offset = offset;
  /* Advance across space reserved for symbol table to locate
     start of string table.  */
  offset += nsyms * SYMESZ;

  /* Write out file symbol.  */
  memset (&syms[0], 0, sizeof (syms));
  if (!u64)
    strcpy ((char *)&syms[0].sym.u.xcoff32.n.n_name[0], ".file");
  set_16 (&syms[0].sym.n_scnum[0], N_DEBUG);
  set_16 (&syms[0].sym.n_type[0], IMAGE_SYM_TYPE);
  syms[0].sym.n_sclass[0] = C_FILE;
  syms[0].sym.n_numaux[0] = 1;
  /* The name need not be nul-terminated if it fits into the x_fname field
     directly, but must be if it has to be placed into the string table.  */
  sflen = strlen (source_filename);
  if (sflen <= FILNMLEN)
    memcpy (&syms[1].aux.x_file.x_fname[0], source_filename, sflen);
  else
    {
      set_32 (&syms[1].aux.x_file._x.x_offset[0], name_offset);
      if (!simple_object_internal_write (descriptor, offset + name_offset,
                                         ((const unsigned char *)
                                          source_filename),
                                         sflen + 1, &errmsg, err))
        return errmsg;
      name_offset += strlen (source_filename) + 1;
    }
  if (!simple_object_internal_write (descriptor, symtab_offset,
                                     (const unsigned char *) &syms[0],
                                     sizeof (syms), &errmsg, err))
    return errmsg;

  /* Write the string table length, followed by the strings and section
     symbols in step with each other.  */
  set_32 (strsizebuf, name_offset);
  if (!simple_object_internal_write (descriptor, offset, strsizebuf, 4,
                                     &errmsg, err))
    return errmsg;

  name_offset = 4;
  secsym_offset = symtab_offset + sizeof (syms);
  memset (&syms[0], 0, sizeof (syms));
  set_16 (&syms[0].sym.n_type[0], IMAGE_SYM_TYPE);
  syms[0].sym.n_sclass[0] = C_STAT;
  syms[0].sym.n_numaux[0] = 1;
  secnum = 1;

  for (section = sobj->sections; section != NULL; section = section->next)
    {
      size_t namelen;
      size_t scnsize;
      struct simple_object_write_section_buffer *buffer;

      namelen = strlen (section->name);
      set_16 (&syms[0].sym.n_scnum[0], secnum++);
      scnsize = 0;
      for (buffer = section->buffers; buffer != NULL; buffer = buffer->next)
        scnsize += buffer->size;
      set_32 (&syms[1].aux.x_scn.x_scnlen[0], scnsize);
      if (namelen > SCNNMLEN)
        {
          set_32 (&syms[0].sym.u.xcoff32.n.n.n_zeroes[0], 0);
          set_32 (&syms[0].sym.u.xcoff32.n.n.n_offset[0], name_offset);
          if (!simple_object_internal_write (descriptor, offset + name_offset,
                                             ((const unsigned char *)
                                              section->name),
                                             namelen + 1, &errmsg, err))
            return errmsg;
          name_offset += namelen + 1;
        }
      else
        {
          memcpy (&syms[0].sym.u.xcoff32.n.n_name[0], section->name,
                  strlen (section->name));
          memset (&syms[0].sym.u.xcoff32.n.n_name[strlen (section->name)], 0,
                  N_SYMNMLEN - strlen (section->name));
        }

      if (!simple_object_internal_write (descriptor, secsym_offset,
                                         (const unsigned char *) &syms[0],
                                         sizeof (syms), &errmsg, err))
        return errmsg;
      secsym_offset += sizeof (syms);
    }

  if (!simple_object_xcoff_write_filehdr (sobj, descriptor, nscns,
                                         symtab_offset, nsyms, &errmsg, err))
    return errmsg;

  return NULL;
}

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

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

/* The XCOFF functions.  */

const struct simple_object_functions simple_object_xcoff_functions =
{
  simple_object_xcoff_match,
  simple_object_xcoff_find_sections,
  simple_object_xcoff_fetch_attributes,
  simple_object_xcoff_release_read,
  simple_object_xcoff_attributes_merge,
  simple_object_xcoff_release_attributes,
  simple_object_xcoff_start_write,
  simple_object_xcoff_write_to_file,
  simple_object_xcoff_release_write
};