Hackfix and re-enable strtoull and wcstoull, see bug #3798.

[sdcc.git] / sdcc / support / sdbinutils / libiberty / simple-object-mach-o.c

/* simple-object-mach-o.c -- routines to manipulate Mach-O object files.
   Copyright (C) 2010-2022 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 <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"

/* Mach-O structures and constants.  */

/* Mach-O header (32-bit version).  */

struct mach_o_header_32
{
  unsigned char magic[4];       /* Magic number.  */
  unsigned char cputype[4];     /* CPU that this object is for.  */
  unsigned char cpusubtype[4];  /* CPU subtype.  */
  unsigned char filetype[4];    /* Type of file.  */
  unsigned char ncmds[4];       /* Number of load commands.  */
  unsigned char sizeofcmds[4];  /* Total size of load commands.  */
  unsigned char flags[4];       /* Flags for special featues.  */
};

/* Mach-O header (64-bit version).  */

struct mach_o_header_64
{
  unsigned char magic[4];       /* Magic number.  */
  unsigned char cputype[4];     /* CPU that this object is for.  */
  unsigned char cpusubtype[4];  /* CPU subtype.  */
  unsigned char filetype[4];    /* Type of file.  */
  unsigned char ncmds[4];       /* Number of load commands.  */
  unsigned char sizeofcmds[4];  /* Total size of load commands.  */
  unsigned char flags[4];       /* Flags for special featues.  */
  unsigned char reserved[4];    /* Reserved.  Duh.  */
};

/* For magic field in header.  */

#define MACH_O_MH_MAGIC                 0xfeedface
#define MACH_O_MH_MAGIC_64              0xfeedfacf

/* For filetype field in header.  */

#define MACH_O_MH_OBJECT                0x01

/* A Mach-O file is a list of load commands.  This is the header of a
   load command.  */

struct mach_o_load_command
{
  unsigned char cmd[4];         /* The type of load command.  */
  unsigned char cmdsize[4];     /* Size in bytes of entire command.  */
};

/* For cmd field in load command.   */

#define MACH_O_LC_SEGMENT               0x01
#define MACH_O_LC_SEGMENT_64            0x19

/* LC_SEGMENT load command.  */

struct mach_o_segment_command_32
{
  unsigned char cmd[4];         /* The type of load command (LC_SEGMENT).  */
  unsigned char cmdsize[4];     /* Size in bytes of entire command.  */
  unsigned char segname[16];    /* Name of this segment.  */
  unsigned char vmaddr[4];      /* Virtual memory address of this segment.  */
  unsigned char vmsize[4];      /* Size there, in bytes.  */
  unsigned char fileoff[4];     /* Offset in bytes of the data to be mapped.  */
  unsigned char filesize[4];    /* Size in bytes on disk.  */
  unsigned char maxprot[4];     /* Maximum permitted vmem protection.  */
  unsigned char initprot[4];    /* Initial vmem protection.  */
  unsigned char nsects[4];      /* Number of sections in this segment.  */
  unsigned char flags[4];       /* Flags that affect the loading.  */
};

/* LC_SEGMENT_64 load command.  */

struct mach_o_segment_command_64
{
  unsigned char cmd[4];         /* The type of load command (LC_SEGMENT_64).  */
  unsigned char cmdsize[4];     /* Size in bytes of entire command.  */
  unsigned char segname[16];    /* Name of this segment.  */
  unsigned char vmaddr[8];      /* Virtual memory address of this segment.  */
  unsigned char vmsize[8];      /* Size there, in bytes.  */
  unsigned char fileoff[8];     /* Offset in bytes of the data to be mapped.  */
  unsigned char filesize[8];    /* Size in bytes on disk.  */
  unsigned char maxprot[4];     /* Maximum permitted vmem protection.  */
  unsigned char initprot[4];    /* Initial vmem protection.  */
  unsigned char nsects[4];      /* Number of sections in this segment.  */
  unsigned char flags[4];       /* Flags that affect the loading.  */
};

/* 32-bit section header.  */

struct mach_o_section_32
{
  unsigned char sectname[16];   /* Section name.  */
  unsigned char segname[16];    /* Segment that the section belongs to.  */
  unsigned char addr[4];        /* Address of this section in memory.  */
  unsigned char size[4];        /* Size in bytes of this section.  */
  unsigned char offset[4];      /* File offset of this section.  */
  unsigned char align[4];       /* log2 of this section's alignment.  */
  unsigned char reloff[4];      /* File offset of this section's relocs.  */
  unsigned char nreloc[4];      /* Number of relocs for this section.  */
  unsigned char flags[4];       /* Section flags/attributes.  */
  unsigned char reserved1[4];
  unsigned char reserved2[4];
};

/* 64-bit section header.  */

struct mach_o_section_64
{
  unsigned char sectname[16];   /* Section name.  */
  unsigned char segname[16];    /* Segment that the section belongs to.  */
  unsigned char addr[8];        /* Address of this section in memory.  */
  unsigned char size[8];        /* Size in bytes of this section.  */
  unsigned char offset[4];      /* File offset of this section.  */
  unsigned char align[4];       /* log2 of this section's alignment.  */
  unsigned char reloff[4];      /* File offset of this section's relocs.  */
  unsigned char nreloc[4];      /* Number of relocs for this section.  */
  unsigned char flags[4];       /* Section flags/attributes.  */
  unsigned char reserved1[4];
  unsigned char reserved2[4];
  unsigned char reserved3[4];
};

/* Flags for Mach-O sections.  */

#define MACH_O_S_ATTR_DEBUG                     0x02000000

/* The length of a segment or section name.  */

#define MACH_O_NAME_LEN (16)

/* A GNU specific extension for long section names.  */

#define GNU_SECTION_NAMES "__section_names"

/* A GNU-specific extension to wrap multiple sections using three
   mach-o sections within a given segment.  The section '__wrapper_sects'
   is subdivided according to the index '__wrapper_index' and each sub
   sect is named according to the names supplied in '__wrapper_names'.  */

#define GNU_WRAPPER_SECTS "__wrapper_sects"
#define GNU_WRAPPER_INDEX "__wrapper_index"
#define GNU_WRAPPER_NAMES "__wrapper_names"

/* Private data for an simple_object_read.  */

struct simple_object_mach_o_read
{
  /* User specified segment name.  */
  char *segment_name;
  /* Magic number.  */
  unsigned int magic;
  /* Whether this file is big-endian.  */
  int is_big_endian;
  /* CPU type from header.  */
  unsigned int cputype;
  /* CPU subtype from header.  */
  unsigned int cpusubtype;
  /* Number of commands, from header.  */
  unsigned int ncmds;
  /* Flags from header.  */
  unsigned int flags;
  /* Reserved field from header, only used on 64-bit.  */
  unsigned int reserved;
};

/* Private data for an simple_object_attributes.  */

struct simple_object_mach_o_attributes
{
  /* Magic number.  */
  unsigned int magic;
  /* Whether this file is big-endian.  */
  int is_big_endian;
  /* CPU type from header.  */
  unsigned int cputype;
  /* CPU subtype from header.  */
  unsigned int cpusubtype;
  /* Flags from header.  */
  unsigned int flags;
  /* Reserved field from header, only used on 64-bit.  */
  unsigned int reserved;
};

/* See if we have a Mach-O MH_OBJECT file:

   A standard MH_OBJECT (from as) will have three load commands:
   0 - LC_SEGMENT/LC_SEGMENT64
   1 - LC_SYMTAB
   2 - LC_DYSYMTAB

   The LC_SEGMENT/LC_SEGMENT64 will introduce a single anonymous segment
   containing all the sections.

   Files written by simple-object will have only the segment command
   (no symbol tables).  */

static void *
simple_object_mach_o_match (
    unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN],
    int descriptor,
    off_t offset,
    const char *segment_name,
    const char **errmsg,
    int *err)
{
  unsigned int magic;
  int is_big_endian;
  unsigned int (*fetch_32) (const unsigned char *);
  unsigned int filetype;
  struct simple_object_mach_o_read *omr;
  unsigned char buf[sizeof (struct mach_o_header_64)];
  unsigned char *b;

  magic = simple_object_fetch_big_32 (header);
  if (magic == MACH_O_MH_MAGIC || magic == MACH_O_MH_MAGIC_64)
    is_big_endian = 1;
  else
    {
      magic = simple_object_fetch_little_32 (header);
      if (magic == MACH_O_MH_MAGIC || magic == MACH_O_MH_MAGIC_64)
        is_big_endian = 0;
      else
        {
          *errmsg = NULL;
          *err = 0;
          return NULL;
        }
    }

#ifndef UNSIGNED_64BIT_TYPE
  if (magic == MACH_O_MH_MAGIC_64)
    {
      *errmsg = "64-bit Mach-O objects not supported";
      *err = 0;
      return NULL;
    }
#endif

  /* We require the user to provide a segment name.  This is
     unfortunate but I don't see any good choices here.  */

  if (segment_name == NULL)
    {
      *errmsg = "Mach-O file found but no segment name specified";
      *err = 0;
      return NULL;
    }

  if (strlen (segment_name) > MACH_O_NAME_LEN)
    {
      *errmsg = "Mach-O segment name too long";
      *err = 0;
      return NULL;
    }

  /* The 32-bit and 64-bit headers are similar enough that we can use
     the same code.  */

  fetch_32 = (is_big_endian
              ? simple_object_fetch_big_32
              : simple_object_fetch_little_32);

  if (!simple_object_internal_read (descriptor, offset, buf,
                                    (magic == MACH_O_MH_MAGIC
                                     ? sizeof (struct mach_o_header_32)
                                     : sizeof (struct mach_o_header_64)),
                                    errmsg, err))
    return NULL;

  b = &buf[0];

  filetype = (*fetch_32) (b + offsetof (struct mach_o_header_32, filetype));
  if (filetype != MACH_O_MH_OBJECT)
    {
      *errmsg = "Mach-O file is not object file";
      *err = 0;
      return NULL;
    }

  omr = XNEW (struct simple_object_mach_o_read);
  omr->segment_name = xstrdup (segment_name);
  omr->magic = magic;
  omr->is_big_endian = is_big_endian;
  omr->cputype = (*fetch_32) (b + offsetof (struct mach_o_header_32, cputype));
  omr->cpusubtype = (*fetch_32) (b
                                 + offsetof (struct mach_o_header_32,
                                             cpusubtype));
  omr->ncmds = (*fetch_32) (b + offsetof (struct mach_o_header_32, ncmds));
  omr->flags = (*fetch_32) (b + offsetof (struct mach_o_header_32, flags));
  if (magic == MACH_O_MH_MAGIC)
    omr->reserved = 0;
  else
    omr->reserved = (*fetch_32) (b
                                 + offsetof (struct mach_o_header_64,
                                             reserved));

  return (void *) omr;
}

/* Get the file offset and size from a section header.  */

static void
simple_object_mach_o_section_info (int is_big_endian, int is_32,
                                   const unsigned char *sechdr, off_t *offset,
                                   size_t *size)
{
  unsigned int (*fetch_32) (const unsigned char *);
  ulong_type (*fetch_64) (const unsigned char *);

  fetch_32 = (is_big_endian
              ? simple_object_fetch_big_32
              : simple_object_fetch_little_32);

  fetch_64 = NULL;
#ifdef UNSIGNED_64BIT_TYPE
  fetch_64 = (is_big_endian
              ? simple_object_fetch_big_64
              : simple_object_fetch_little_64);
#endif

  if (is_32)
    {
      *offset = fetch_32 (sechdr
                          + offsetof (struct mach_o_section_32, offset));
      *size = fetch_32 (sechdr
                        + offsetof (struct mach_o_section_32, size));
    }
  else
    {
      *offset = fetch_32 (sechdr
                          + offsetof (struct mach_o_section_64, offset));
      *size = fetch_64 (sechdr
                        + offsetof (struct mach_o_section_64, size));
    }
}

/* Handle a segment in a Mach-O Object file.

   This will callback to the function pfn for each "section found" the meaning
   of which depends on gnu extensions to mach-o:

   If we find mach-o sections (with the segment name as specified) which also
   contain: a 'sects' wrapper, an index, and a  name table, we expand this into
   as many sections as are specified in the index.  In this case, there will
   be a callback for each of these.

   We will also allow an extension that permits long names (more than 16
   characters) to be used with mach-o.  In this case, the section name has
   a specific format embedding an index into a name table, and the file must
   contain such name table.

   Return 1 if we should continue, 0 if the caller should return.  */

#define SOMO_SECTS_PRESENT 0x01
#define SOMO_INDEX_PRESENT 0x02
#define SOMO_NAMES_PRESENT 0x04
#define SOMO_LONGN_PRESENT 0x08
#define SOMO_WRAPPING (SOMO_SECTS_PRESENT | SOMO_INDEX_PRESENT \
                       | SOMO_NAMES_PRESENT)

static int
simple_object_mach_o_segment (simple_object_read *sobj, off_t offset,
                              const unsigned char *segbuf,
                              int (*pfn) (void *, const char *, off_t offset,
                                          off_t length),
                              void *data,
                              const char **errmsg, int *err)
{
  struct simple_object_mach_o_read *omr =
    (struct simple_object_mach_o_read *) sobj->data;
  unsigned int (*fetch_32) (const unsigned char *);
  int is_32;
  size_t seghdrsize;
  size_t sechdrsize;
  size_t segname_offset;
  size_t sectname_offset;
  unsigned int nsects;
  unsigned char *secdata;
  unsigned int i;
  unsigned int gnu_sections_found;
  unsigned int strtab_index;
  unsigned int index_index;
  unsigned int nametab_index;
  unsigned int sections_index;
  char *strtab;
  char *nametab;
  unsigned char *index;
  size_t strtab_size;
  size_t nametab_size;
  size_t index_size;
  unsigned int n_wrapped_sects;
  size_t wrapper_sect_size;
  off_t wrapper_sect_offset = 0;

  fetch_32 = (omr->is_big_endian
              ? simple_object_fetch_big_32
              : simple_object_fetch_little_32);

  is_32 = omr->magic == MACH_O_MH_MAGIC;

  if (is_32)
    {
      seghdrsize = sizeof (struct mach_o_segment_command_32);
      sechdrsize = sizeof (struct mach_o_section_32);
      segname_offset = offsetof (struct mach_o_section_32, segname);
      sectname_offset = offsetof (struct mach_o_section_32, sectname);
      nsects = (*fetch_32) (segbuf
                            + offsetof (struct mach_o_segment_command_32,
                                        nsects));
    }
  else
    {
      seghdrsize = sizeof (struct mach_o_segment_command_64);
      sechdrsize = sizeof (struct mach_o_section_64);
      segname_offset = offsetof (struct mach_o_section_64, segname);
      sectname_offset = offsetof (struct mach_o_section_64, sectname);
      nsects = (*fetch_32) (segbuf
                            + offsetof (struct mach_o_segment_command_64,
                                        nsects));
    }

  /* Fetch the section headers from the segment command.  */

  secdata = XNEWVEC (unsigned char, nsects * sechdrsize);
  if (!simple_object_internal_read (sobj->descriptor, offset + seghdrsize,
                                    secdata, nsects * sechdrsize, errmsg, err))
    {
      XDELETEVEC (secdata);
      return 0;
    }

  /* Scan for special sections that signal GNU extensions to the format.  */

  gnu_sections_found = 0;
  index_index = nsects;
  sections_index = nsects;
  strtab_index = nsects;
  nametab_index = nsects;
  for (i = 0; i < nsects; ++i)
    {
      size_t nameoff;

      nameoff = i * sechdrsize + segname_offset;
      if (strcmp ((char *) secdata + nameoff, omr->segment_name) != 0)
        continue;

      nameoff = i * sechdrsize + sectname_offset;
      if (strcmp ((char *) secdata + nameoff, GNU_WRAPPER_NAMES) == 0)
        {
          nametab_index = i;
          gnu_sections_found |= SOMO_NAMES_PRESENT;
        }
      else if (strcmp ((char *) secdata + nameoff, GNU_WRAPPER_INDEX) == 0)
        {
          index_index = i;
          gnu_sections_found |= SOMO_INDEX_PRESENT;
        }
      else if (strcmp ((char *) secdata + nameoff, GNU_WRAPPER_SECTS) == 0)
        {
          sections_index = i;
          gnu_sections_found |= SOMO_SECTS_PRESENT;
        }
      else if (strcmp ((char *) secdata + nameoff, GNU_SECTION_NAMES) == 0)
        {
          strtab_index = i;
          gnu_sections_found |= SOMO_LONGN_PRESENT;
        }
    }

  /* If any of the special wrapper section components is present, then
     they all should be.  */

  if ((gnu_sections_found & SOMO_WRAPPING) != 0)
    {
      off_t nametab_offset;
      off_t index_offset;

      if ((gnu_sections_found & SOMO_WRAPPING) != SOMO_WRAPPING)
        {
          *errmsg = "GNU Mach-o section wrapper: required section missing";
          *err = 0; /* No useful errno.  */
          XDELETEVEC (secdata);
          return 0;
        }

      /* Fetch the name table.  */

      simple_object_mach_o_section_info (omr->is_big_endian, is_32,
                                         secdata + nametab_index * sechdrsize,
                                         &nametab_offset, &nametab_size);
      nametab = XNEWVEC (char, nametab_size);
      if (!simple_object_internal_read (sobj->descriptor,
                                        sobj->offset + nametab_offset,
                                        (unsigned char *) nametab, nametab_size,
                                        errmsg, err))
        {
          XDELETEVEC (nametab);
          XDELETEVEC (secdata);
          return 0;
        }

      /* Fetch the index.  */

      simple_object_mach_o_section_info (omr->is_big_endian, is_32,
                                         secdata + index_index * sechdrsize,
                                         &index_offset, &index_size);
      index = XNEWVEC (unsigned char, index_size);
      if (!simple_object_internal_read (sobj->descriptor,
                                        sobj->offset + index_offset,
                                        index, index_size,
                                        errmsg, err))
        {
          XDELETEVEC (index);
          XDELETEVEC (nametab);
          XDELETEVEC (secdata);
          return 0;
        }

      /* The index contains 4 unsigned ints per sub-section:
         sub-section offset/length, sub-section name/length.
         We fix this for both 32 and 64 bit mach-o for now, since
         other fields limit the maximum size of an object to 4G.  */
      n_wrapped_sects = index_size / 16;

      /* Get the parameters for the wrapper too.  */
      simple_object_mach_o_section_info (omr->is_big_endian, is_32,
                                         secdata + sections_index * sechdrsize,
                                         &wrapper_sect_offset,
                                         &wrapper_sect_size);
    }
  else
    {
      index = NULL;
      index_size = 0;
      nametab = NULL;
      nametab_size = 0;
      n_wrapped_sects = 0;
    }

  /* If we have a long names section, fetch it.  */

  if ((gnu_sections_found & SOMO_LONGN_PRESENT) != 0)
    {
      off_t strtab_offset;

      simple_object_mach_o_section_info (omr->is_big_endian, is_32,
                                         secdata + strtab_index * sechdrsize,
                                         &strtab_offset, &strtab_size);
      strtab = XNEWVEC (char, strtab_size);
      if (!simple_object_internal_read (sobj->descriptor,
                                        sobj->offset + strtab_offset,
                                        (unsigned char *) strtab, strtab_size,
                                        errmsg, err))
        {
          XDELETEVEC (strtab);
          XDELETEVEC (index);
          XDELETEVEC (nametab);
          XDELETEVEC (secdata);
          return 0;
        }
    }
  else
    {
      strtab = NULL;
      strtab_size = 0;
      strtab_index = nsects;
    }

  /* Process the sections.  */

  for (i = 0; i < nsects; ++i)
    {
      const unsigned char *sechdr;
      char namebuf[MACH_O_NAME_LEN * 2 + 2];
      char *name;
      off_t secoffset;
      size_t secsize;
      int l;

      sechdr = secdata + i * sechdrsize;

      /* We've already processed the long section names.  */

      if ((gnu_sections_found & SOMO_LONGN_PRESENT) != 0
          && i == strtab_index)
        continue;

      /* We only act on the segment named.  */

      if (strcmp ((char *) sechdr + segname_offset, omr->segment_name) != 0)
        continue;

      /* Process sections associated with the wrapper.  */

      if ((gnu_sections_found & SOMO_WRAPPING) != 0)
        {
          if (i == nametab_index || i == index_index)
            continue;

          if (i == sections_index)
            {
              unsigned int j;
              for (j = 0; j < n_wrapped_sects; ++j)
                {
                  unsigned int subsect_offset, subsect_length, name_offset;
                  subsect_offset = (*fetch_32) (index + 16 * j);
                  subsect_length = (*fetch_32) (index + 16 * j + 4);
                  name_offset = (*fetch_32) (index + 16 * j + 8);
                  /* We don't need the name_length yet.  */

                  secoffset = wrapper_sect_offset + subsect_offset;
                  secsize = subsect_length;
                  name = nametab + name_offset;

                  if (!(*pfn) (data, name, secoffset, secsize))
                    {
                      *errmsg = NULL;
                      *err = 0;
                      XDELETEVEC (index);
                      XDELETEVEC (nametab);
                      XDELETEVEC (strtab);
                      XDELETEVEC (secdata);
                      return 0;
                    }
                }
              continue;
            }
        }

      if ((gnu_sections_found & SOMO_LONGN_PRESENT) != 0)
        {
          memcpy (namebuf, sechdr + sectname_offset, MACH_O_NAME_LEN);
          namebuf[MACH_O_NAME_LEN] = '\0';

          name = &namebuf[0];
          if (strtab != NULL && name[0] == '_' && name[1] == '_')
            {
              unsigned long stringoffset;

              if (sscanf (name + 2, "%08lX", &stringoffset) == 1)
                {
                  if (stringoffset >= strtab_size)
                    {
                      *errmsg = "section name offset out of range";
                      *err = 0;
                      XDELETEVEC (index);
                      XDELETEVEC (nametab);
                      XDELETEVEC (strtab);
                      XDELETEVEC (secdata);
                      return 0;
                    }

                  name = strtab + stringoffset;
                }
          }
        }
      else
        {
           /* Otherwise, make a name like __segment,__section as per the
              convention in mach-o asm.  */
          name = &namebuf[0];
          memcpy (namebuf, (char *) sechdr + segname_offset, MACH_O_NAME_LEN);
          namebuf[MACH_O_NAME_LEN] = '\0';
          l = strlen (namebuf);
          namebuf[l] = ',';
          memcpy (namebuf + l + 1, (char *) sechdr + sectname_offset,
                  MACH_O_NAME_LEN);
          namebuf[l + 1 + MACH_O_NAME_LEN] = '\0';
        }

      simple_object_mach_o_section_info (omr->is_big_endian, is_32, sechdr,
                                         &secoffset, &secsize);

      if (!(*pfn) (data, name, secoffset, secsize))
        {
          *errmsg = NULL;
          *err = 0;
          XDELETEVEC (index);
          XDELETEVEC (nametab);
          XDELETEVEC (strtab);
          XDELETEVEC (secdata);
          return 0;
        }
    }

  XDELETEVEC (index);
  XDELETEVEC (nametab);
  XDELETEVEC (strtab);
  XDELETEVEC (secdata);

  return 1;
}

/* Find all sections in a Mach-O file.  */

static const char *
simple_object_mach_o_find_sections (simple_object_read *sobj,
                                    int (*pfn) (void *, const char *,
                                                off_t offset, off_t length),
                                    void *data,
                                    int *err)
{
  struct simple_object_mach_o_read *omr =
    (struct simple_object_mach_o_read *) sobj->data;
  off_t offset;
  size_t seghdrsize;
  unsigned int (*fetch_32) (const unsigned char *);
  const char *errmsg;
  unsigned int i;

  if (omr->magic == MACH_O_MH_MAGIC)
    {
      offset = sizeof (struct mach_o_header_32);
      seghdrsize = sizeof (struct mach_o_segment_command_32);
    }
  else
    {
      offset = sizeof (struct mach_o_header_64);
      seghdrsize = sizeof (struct mach_o_segment_command_64);
    }

  fetch_32 = (omr->is_big_endian
              ? simple_object_fetch_big_32
              : simple_object_fetch_little_32);

  for (i = 0; i < omr->ncmds; ++i)
    {
      unsigned char loadbuf[sizeof (struct mach_o_load_command)];
      unsigned int cmd;
      unsigned int cmdsize;

      if (!simple_object_internal_read (sobj->descriptor,
                                        sobj->offset + offset,
                                        loadbuf,
                                        sizeof (struct mach_o_load_command),
                                        &errmsg, err))
        return errmsg;

      cmd = (*fetch_32) (loadbuf + offsetof (struct mach_o_load_command, cmd));
      cmdsize = (*fetch_32) (loadbuf
                             + offsetof (struct mach_o_load_command, cmdsize));

      if (cmd == MACH_O_LC_SEGMENT || cmd == MACH_O_LC_SEGMENT_64)
        {
          unsigned char segbuf[sizeof (struct mach_o_segment_command_64)];
          int r;

          if (!simple_object_internal_read (sobj->descriptor,
                                            sobj->offset + offset,
                                            segbuf, seghdrsize, &errmsg, err))
            return errmsg;

          r = simple_object_mach_o_segment (sobj, offset, segbuf, pfn,
                                            data, &errmsg, err);
          if (!r)
            return errmsg;
        }

      offset += cmdsize;
    }

  return NULL;
}

/* Fetch the attributes for an simple_object_read.  */

static void *
simple_object_mach_o_fetch_attributes (simple_object_read *sobj,
                                       const char **errmsg ATTRIBUTE_UNUSED,
                                       int *err ATTRIBUTE_UNUSED)
{
  struct simple_object_mach_o_read *omr =
    (struct simple_object_mach_o_read *) sobj->data;
  struct simple_object_mach_o_attributes *ret;

  ret = XNEW (struct simple_object_mach_o_attributes);
  ret->magic = omr->magic;
  ret->is_big_endian = omr->is_big_endian;
  ret->cputype = omr->cputype;
  ret->cpusubtype = omr->cpusubtype;
  ret->flags = omr->flags;
  ret->reserved = omr->reserved;
  return ret;
}

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

static void
simple_object_mach_o_release_read (void *data)
{
  struct simple_object_mach_o_read *omr =
    (struct simple_object_mach_o_read *) data;

  free (omr->segment_name);
  XDELETE (omr);
}

/* Compare two attributes structures.  */

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

  if (to->magic != from->magic
      || to->is_big_endian != from->is_big_endian
      || to->cputype != from->cputype)
    {
      *err = 0;
      return "Mach-O object format mismatch";
    }
  return NULL;
}

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

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

/* Prepare to write out a file.  */

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

/* Write out the header of a Mach-O file.  */

static int
simple_object_mach_o_write_header (simple_object_write *sobj, int descriptor,
                                   size_t nsects, const char **errmsg,
                                   int *err)
{
  struct simple_object_mach_o_attributes *attrs =
    (struct simple_object_mach_o_attributes *) sobj->data;
  void (*set_32) (unsigned char *, unsigned int);
  unsigned char hdrbuf[sizeof (struct mach_o_header_64)];
  unsigned char *hdr;
  size_t wrsize;

  set_32 = (attrs->is_big_endian
            ? simple_object_set_big_32
            : simple_object_set_little_32);

  memset (hdrbuf, 0, sizeof hdrbuf);

  /* The 32-bit and 64-bit headers start out the same.  */

  hdr = &hdrbuf[0];
  set_32 (hdr + offsetof (struct mach_o_header_32, magic), attrs->magic);
  set_32 (hdr + offsetof (struct mach_o_header_32, cputype), attrs->cputype);
  set_32 (hdr + offsetof (struct mach_o_header_32, cpusubtype),
          attrs->cpusubtype);
  set_32 (hdr + offsetof (struct mach_o_header_32, filetype), MACH_O_MH_OBJECT);
  set_32 (hdr + offsetof (struct mach_o_header_32, ncmds), 1);
  set_32 (hdr + offsetof (struct mach_o_header_32, flags), attrs->flags);
  if (attrs->magic == MACH_O_MH_MAGIC)
    {
      wrsize = sizeof (struct mach_o_header_32);
      set_32 (hdr + offsetof (struct mach_o_header_32, sizeofcmds),
              (sizeof (struct mach_o_segment_command_32)
               + nsects * sizeof (struct mach_o_section_32)));
    }
  else
    {
      set_32 (hdr + offsetof (struct mach_o_header_64, sizeofcmds),
              (sizeof (struct mach_o_segment_command_64)
               + nsects * sizeof (struct mach_o_section_64)));
      set_32 (hdr + offsetof (struct mach_o_header_64, reserved),
              attrs->reserved);
      wrsize = sizeof (struct mach_o_header_64);
    }

  return simple_object_internal_write (descriptor, 0, hdrbuf, wrsize,
                                       errmsg, err);
}

/* Write a Mach-O section header.  */

static int
simple_object_mach_o_write_section_header (simple_object_write *sobj,
                                           int descriptor,
                                           size_t sechdr_offset,
                                           const char *name, const char *segn,
                                           size_t secaddr, size_t secsize,
                                           size_t offset, unsigned int align,
                                           const char **errmsg, int *err)
{
  struct simple_object_mach_o_attributes *attrs =
    (struct simple_object_mach_o_attributes *) sobj->data;
  void (*set_32) (unsigned char *, unsigned int);
  unsigned char hdrbuf[sizeof (struct mach_o_section_64)];
  unsigned char *hdr;
  size_t sechdrsize;

  set_32 = (attrs->is_big_endian
            ? simple_object_set_big_32
            : simple_object_set_little_32);

  memset (hdrbuf, 0, sizeof hdrbuf);

  hdr = &hdrbuf[0];
  if (attrs->magic == MACH_O_MH_MAGIC)
    {
      strncpy ((char *) hdr + offsetof (struct mach_o_section_32, sectname),
               name, MACH_O_NAME_LEN);
      strncpy ((char *) hdr + offsetof (struct mach_o_section_32, segname),
               segn, MACH_O_NAME_LEN);
      set_32 (hdr + offsetof (struct mach_o_section_32, addr), secaddr);
      set_32 (hdr + offsetof (struct mach_o_section_32, size), secsize);
      set_32 (hdr + offsetof (struct mach_o_section_32, offset), offset);
      set_32 (hdr + offsetof (struct mach_o_section_32, align), align);
      /* reloff left as zero.  */
      /* nreloc left as zero.  */
      set_32 (hdr + offsetof (struct mach_o_section_32, flags),
              MACH_O_S_ATTR_DEBUG);
      /* reserved1 left as zero.  */
      /* reserved2 left as zero.  */
      sechdrsize = sizeof (struct mach_o_section_32);
    }
  else
    {
#ifdef UNSIGNED_64BIT_TYPE
      void (*set_64) (unsigned char *, ulong_type);

      set_64 = (attrs->is_big_endian
                ? simple_object_set_big_64
                : simple_object_set_little_64);

      strncpy ((char *) hdr + offsetof (struct mach_o_section_64, sectname),
               name, MACH_O_NAME_LEN);
      strncpy ((char *) hdr + offsetof (struct mach_o_section_64, segname),
               segn, MACH_O_NAME_LEN);
      set_64 (hdr + offsetof (struct mach_o_section_64, addr), secaddr);
      set_64 (hdr + offsetof (struct mach_o_section_64, size), secsize);
      set_32 (hdr + offsetof (struct mach_o_section_64, offset), offset);
      set_32 (hdr + offsetof (struct mach_o_section_64, align), align);
      /* reloff left as zero.  */
      /* nreloc left as zero.  */
      set_32 (hdr + offsetof (struct mach_o_section_64, flags),
              MACH_O_S_ATTR_DEBUG);
      /* reserved1 left as zero.  */
      /* reserved2 left as zero.  */
      /* reserved3 left as zero.  */
#endif
      sechdrsize = sizeof (struct mach_o_section_64);
    }

  return simple_object_internal_write (descriptor, sechdr_offset, hdr,
                                       sechdrsize, errmsg, err);
}

/* Write out the single (anonymous) segment containing the sections of a Mach-O
   Object file.

   As a GNU extension to mach-o, when the caller specifies a segment name in
   sobj->segment_name, all the sections passed will be output under a single
   mach-o section header.  The caller's sections are indexed within this
   'wrapper' section by a table stored in a second mach-o section.  Finally,
   arbitrary length section names are permitted by the extension and these are
   stored in a table in a third mach-o section.

   Note that this is only likely to make any sense for the __GNU_LTO segment
   at present.

   If the wrapper extension is not in force, we assume that the section name
   is in the form __SEGMENT_NAME,__section_name as per Mach-O asm.  */

static int
simple_object_mach_o_write_segment (simple_object_write *sobj, int descriptor,
                                    size_t *nsects, const char **errmsg,
                                    int *err)
{
  struct simple_object_mach_o_attributes *attrs =
    (struct simple_object_mach_o_attributes *) sobj->data;
  void (*set_32) (unsigned char *, unsigned int);
  size_t hdrsize;
  size_t seghdrsize;
  size_t sechdrsize;
  size_t cmdsize;
  size_t offset;
  size_t sechdr_offset;
  size_t secaddr;
  unsigned int name_offset;
  simple_object_write_section *section;
  unsigned char hdrbuf[sizeof (struct mach_o_segment_command_64)];
  unsigned char *hdr;
  size_t nsects_in;
  unsigned int *index;
  char *snames;
  unsigned int sect;

  set_32 = (attrs->is_big_endian
            ? simple_object_set_big_32
            : simple_object_set_little_32);

  /* Write out the sections first.  */

  if (attrs->magic == MACH_O_MH_MAGIC)
    {
      hdrsize = sizeof (struct mach_o_header_32);
      seghdrsize = sizeof (struct mach_o_segment_command_32);
      sechdrsize = sizeof (struct mach_o_section_32);
    }
  else
    {
      hdrsize = sizeof (struct mach_o_header_64);
      seghdrsize = sizeof (struct mach_o_segment_command_64);
      sechdrsize = sizeof (struct mach_o_section_64);
    }

  name_offset = 0;
  *nsects = nsects_in = 0;

  /* Count the number of sections we start with.  */

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

  if (sobj->segment_name != NULL)
    {
      /* We will only write 3 sections: wrapped data, index and names.  */

      *nsects = 3;

      /* The index has four entries per wrapped section:
           Section Offset, length,  Name offset, length.
         Where the offsets are based at the start of the wrapper and name
         sections respectively.
         The values are stored as 32 bit int for both 32 and 64 bit mach-o
         since the size of a mach-o MH_OBJECT cannot exceed 4G owing to
         other constraints.  */

      index = XNEWVEC (unsigned int, nsects_in * 4);

      /* We now need to figure out the size of the names section.  This just
         stores the names as null-terminated c strings, packed without any
         alignment padding.  */

      for (section = sobj->sections, sect = 0; section != NULL;
           section = section->next, sect++)
        {
          index[sect*4+2] = name_offset;
          index[sect*4+3] = strlen (section->name) + 1;
          name_offset += strlen (section->name) + 1;
        }
      snames = XNEWVEC (char, name_offset);
    }
  else
    {
      *nsects = nsects_in;
      index = NULL;
      snames = NULL;
    }

  sechdr_offset = hdrsize + seghdrsize;
  cmdsize = seghdrsize + *nsects * sechdrsize;
  offset = hdrsize + cmdsize;
  secaddr = 0;

  for (section = sobj->sections, sect = 0;
       section != NULL; section = section->next, sect++)
    {
      size_t mask;
      size_t new_offset;
      size_t secsize;
      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 0;
          offset += write;
        }

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

      if (sobj->segment_name != NULL)
        {
          index[sect*4+0] = (unsigned int) offset;
          index[sect*4+1] = secsize;
          /* Stash the section name in our table.  */
          memcpy (snames + index[sect * 4 + 2], section->name,
                  index[sect * 4 + 3]);
        }
      else
        {
          char namebuf[MACH_O_NAME_LEN + 1];
          char segnbuf[MACH_O_NAME_LEN + 1];
          char *comma;

          /* Try to extract segment,section from the input name.  */

          memset (namebuf, 0, sizeof namebuf);
          memset (segnbuf, 0, sizeof segnbuf);
          comma = strchr (section->name, ',');
          if (comma != NULL)
            {
              int len = comma - section->name;
              len = len > MACH_O_NAME_LEN ? MACH_O_NAME_LEN : len;
              strncpy (namebuf, section->name, len);
              strncpy (segnbuf, comma + 1, MACH_O_NAME_LEN);
            }
          else /* just try to copy the name, leave segment blank.  */
            strncpy (namebuf, section->name, MACH_O_NAME_LEN);

          if (!simple_object_mach_o_write_section_header (sobj, descriptor,
                                                          sechdr_offset,
                                                          namebuf, segnbuf,
                                                          secaddr, secsize,
                                                          offset,
                                                          section->align,
                                                          errmsg, err))
            return 0;
          sechdr_offset += sechdrsize;
        }

      offset += secsize;
      secaddr += secsize;
    }

  if (sobj->segment_name != NULL)
    {
      size_t secsize;
      unsigned int i;

      /* Write the section header for the wrapper.  */
      /* Account for any initial aligment - which becomes the alignment for this
         created section.  */

      secsize = (offset - index[0]);
      if (!simple_object_mach_o_write_section_header (sobj, descriptor,
                                                      sechdr_offset,
                                                      GNU_WRAPPER_SECTS,
                                                      sobj->segment_name,
                                                      0 /*secaddr*/,
                                                      secsize, index[0],
                                                      sobj->sections->align,
                                                      errmsg, err))
        return 0;

      /* Subtract the wrapper section start from the begining of each sub
         section.  */

      for (i = 1; i < nsects_in; ++i)
        index[4 * i] -= index[0];
      index[0] = 0;

      /* Swap the indices, if required.  */

      for (i = 0; i < (nsects_in * 4); ++i)
        set_32 ((unsigned char *) &index[i], index[i]);

      sechdr_offset += sechdrsize;

      /* Write out the section names.
         ... the header ...
         name_offset contains the length of the section.  It is not aligned.  */

      if (!simple_object_mach_o_write_section_header (sobj, descriptor,
                                                      sechdr_offset,
                                                      GNU_WRAPPER_NAMES,
                                                      sobj->segment_name,
                                                      0 /*secaddr*/,
                                                      name_offset,
                                                      offset,
                                                      0, errmsg, err))
        return 0;

      /* ... and the content.. */
      if (!simple_object_internal_write (descriptor, offset,
                                         (const unsigned char *) snames,
                                         name_offset, errmsg, err))
        return 0;

      sechdr_offset += sechdrsize;
      secaddr += name_offset;
      offset += name_offset;

      /* Now do the index, we'll align this to 4 bytes although the read code
         will handle unaligned.  */

      offset += 3;
      offset &= ~0x03;
      if (!simple_object_mach_o_write_section_header (sobj, descriptor,
                                                      sechdr_offset,
                                                      GNU_WRAPPER_INDEX,
                                                      sobj->segment_name,
                                                      0 /*secaddr*/,
                                                      nsects_in * 16,
                                                      offset,
                                                      2, errmsg, err))
        return 0;

      /* ... and the content.. */
      if (!simple_object_internal_write (descriptor, offset,
                                         (const unsigned char *) index,
                                         nsects_in*16, errmsg, err))
        return 0;

      XDELETEVEC (index);
      XDELETEVEC (snames);
    }

  /* Write out the segment header.  */

  memset (hdrbuf, 0, sizeof hdrbuf);

  hdr = &hdrbuf[0];
  if (attrs->magic == MACH_O_MH_MAGIC)
    {
      set_32 (hdr + offsetof (struct mach_o_segment_command_32, cmd),
              MACH_O_LC_SEGMENT);
      set_32 (hdr + offsetof (struct mach_o_segment_command_32, cmdsize),
              cmdsize);
     /* MH_OBJECTS have a single, anonymous, segment - so the segment name
         is left empty.  */
      /* vmaddr left as zero.  */
      /* vmsize left as zero.  */
      set_32 (hdr + offsetof (struct mach_o_segment_command_32, fileoff),
              hdrsize + cmdsize);
      set_32 (hdr + offsetof (struct mach_o_segment_command_32, filesize),
              offset - (hdrsize + cmdsize));
      /* maxprot left as zero.  */
      /* initprot left as zero.  */
      set_32 (hdr + offsetof (struct mach_o_segment_command_32, nsects),
              *nsects);
      /* flags left as zero.  */
    }
  else
    {
#ifdef UNSIGNED_64BIT_TYPE
      void (*set_64) (unsigned char *, ulong_type);

      set_64 = (attrs->is_big_endian
                ? simple_object_set_big_64
                : simple_object_set_little_64);

      set_32 (hdr + offsetof (struct mach_o_segment_command_64, cmd),
              MACH_O_LC_SEGMENT);
      set_32 (hdr + offsetof (struct mach_o_segment_command_64, cmdsize),
              cmdsize);
      /* MH_OBJECTS have a single, anonymous, segment - so the segment name
         is left empty.  */
      /* vmaddr left as zero.  */
      /* vmsize left as zero.  */
      set_64 (hdr + offsetof (struct mach_o_segment_command_64, fileoff),
              hdrsize + cmdsize);
      set_64 (hdr + offsetof (struct mach_o_segment_command_64, filesize),
              offset - (hdrsize + cmdsize));
      /* maxprot left as zero.  */
      /* initprot left as zero.  */
      set_32 (hdr + offsetof (struct mach_o_segment_command_64, nsects),
              *nsects);
      /* flags left as zero.  */
#endif
    }

  return simple_object_internal_write (descriptor, hdrsize, hdr, seghdrsize,
                                       errmsg, err);
}

/* Write out a complete Mach-O file.  */

static const char *
simple_object_mach_o_write_to_file (simple_object_write *sobj, int descriptor,
                                    int *err)
{
  size_t nsects = 0;
  const char *errmsg;

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

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

  return NULL;
}

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

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

/* The Mach-O functions.  */

const struct simple_object_functions simple_object_mach_o_functions =
{
  simple_object_mach_o_match,
  simple_object_mach_o_find_sections,
  simple_object_mach_o_fetch_attributes,
  simple_object_mach_o_release_read,
  simple_object_mach_o_attributes_merge,
  simple_object_mach_o_release_attributes,
  simple_object_mach_o_start_write,
  simple_object_mach_o_write_to_file,
  simple_object_mach_o_release_write,
  NULL
};