nasm/output/outmacho.c

/* outmacho.c	output routines for the Netwide Assembler to produce
 *		NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X object files
 *
 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
 * Julian Hall. All rights reserved. The software is
 * redistributable under the licence given in the file "Licence"
 * distributed in the NASM archive.
 */

/* Most of this file is, like Mach-O itself, based on a.out. For more
 * guidelines see outaout.c.  */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include "nasm.h"
#include "nasmlib.h"
#include "outform.h"

#if defined(OF_MACHO)

/* Mach-O in-file header structure sizes */
#define MACHO_HEADER_SIZE	(28)
#define MACHO_SEGCMD_SIZE	(56)
#define MACHO_SECTCMD_SIZE	(68)
#define MACHO_SYMCMD_SIZE	(24)
#define MACHO_NLIST_SIZE	(12)
#define MACHO_RELINFO_SIZE	(8)

/* Mach-O file header values */
#define	MH_MAGIC		(0xfeedface)
#define CPU_TYPE_I386		(7)     /* x86 platform */
#define	CPU_SUBTYPE_I386_ALL	(3)     /* all-x86 compatible */
#define	MH_OBJECT		(0x1)   /* object file */

#define	LC_SEGMENT		(0x1)   /* segment load command */
#define LC_SYMTAB		(0x2)   /* symbol table load command */

#define	VM_PROT_NONE	(0x00)
#define VM_PROT_READ	(0x01)
#define VM_PROT_WRITE	(0x02)
#define VM_PROT_EXECUTE	(0x04)

#define VM_PROT_DEFAULT	(VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE)
#define VM_PROT_ALL	(VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE)

struct section {
    /* nasm internal data */
    struct section *next;
    struct SAA *data;
    long index;
    struct reloc *relocs;

    /* data that goes into the file */
    char sectname[16];          /* what this section is called */
    char segname[16];           /* segment this section will be in */
    unsigned long size;         /* in-memory and -file size  */
    unsigned long nreloc;       /* relocation entry count */
    unsigned long flags;        /* type and attributes (masked) */
};

#define SECTION_TYPE	0x000000ff      /* section type mask */

#define	S_REGULAR	(0x0)   /* standard section */
#define	S_ZEROFILL	(0x1)   /* zerofill, in-memory only */

static struct sectmap {
    const char *nasmsect;
    const char *segname;
    const char *sectname;
    const long flags;
} sectmap[] = { {
".text", "__TEXT", "__text", S_REGULAR}, {
".data", "__DATA", "__data", S_REGULAR}, {
".bss", "__DATA", "__bss", S_ZEROFILL}, {
NULL, NULL, NULL}};

struct reloc {
    /* nasm internal data */
    struct reloc *next;

    /* data that goes into the file */
    long addr;                  /* op's offset in section */
    unsigned int snum:24,       /* contains symbol index if
                                 ** ext otherwise in-file
                                 ** section number */
     pcrel:1,                   /* relative relocation */
     length:2,                  /* 0=byte, 1=word, 2=long */
     ext:1,                     /* external symbol referenced */
     type:4;                    /* reloc type, 0 for us */
};

#define	R_ABS		0       /* absolute relocation */
#define R_SCATTERED	0x80000000      /* reloc entry is scattered if
                                         ** highest bit == 1 */

struct symbol {
    long strx;                  /* string table index */
    unsigned char type;         /* symbol type */
    unsigned char sect;         /* NO_SECT or section number */
    short desc;                 /* for stab debugging, 0 for us */
    unsigned long value;        /* offset of symbol in section */
};

/* symbol type bits */
#define	N_EXT	0x01            /* global or external symbol */

#define	N_UNDF	0x0             /* undefined symbol | n_sect == */
#define	N_ABS	0x2             /* absolute symbol  |  NO_SECT */
#define	N_SECT	0xe             /* defined symbol, n_sect holds
                                 ** section number */

#define	N_TYPE	0x0e            /* type bit mask */

/* special section number values */
#define	NO_SECT		0       /* no section, invalid */
#define MAX_SECT	255     /* maximum number of sections */

static struct section *sects, **sectstail;
static struct SAA *syms;
static unsigned long nsyms;
static struct RAA *extsyms;
static struct SAA *strs;
static unsigned long strslen;

static FILE *machofp;
static efunc error;
static evalfunc evaluate;

extern struct ofmt of_macho;

#define xstrncpy(xdst, xsrc) \
    memset(xdst, '\0', sizeof(xdst));	/* zero out whole buffer */ \
    strncpy(xdst, xsrc, sizeof(xdst));	/* copy over string */ \
    xdst[sizeof(xdst) - 1] = '\0';      /* proper null-termination */

#define align(x, y) \
    (((x) + (y) - 1) & ~((y) - 1))      /* align x to multiple of y */

#define alignlong(x) \
    align(x, sizeof(long))      /* align x to long boundary */

static struct section *get_section_by_name(const char *segname,
                                           const char *sectname)
{
    struct section *s;

    for (s = sects; s != NULL; s = s->next)
        if (!strcmp(s->segname, segname) && !strcmp(s->sectname, sectname))
            break;

    return s;
}

static struct section *get_section_by_index(const long index)
{
    struct section *s;

    for (s = sects; s != NULL; s = s->next)
        if (index == s->index)
            break;

    return s;
}

static long get_section_index_by_name(const char *segname,
                                      const char *sectname)
{
    struct section *s;

    for (s = sects; s != NULL; s = s->next)
        if (!strcmp(s->segname, segname) && !strcmp(s->sectname, sectname))
            return s->index;

    return -1;
}

static char *get_section_name_by_index(const long index)
{
    struct section *s;

    for (s = sects; s != NULL; s = s->next)
        if (index == s->index)
            return s->sectname;

    return NULL;
}

static unsigned char get_section_fileindex_by_index(const long index)
{
    struct section *s;
    unsigned char i = 1;

    for (s = sects; s != NULL && i < MAX_SECT; s = s->next, ++i)
        if (index == s->index)
            return i;

    if (i == MAX_SECT)
        error(ERR_WARNING,
              "too many sections (>255) - clipped by fileindex");

    return NO_SECT;
}

static void macho_init(FILE * fp, efunc errfunc, ldfunc ldef,
                       evalfunc eval)
{
    char zero = 0;

    machofp = fp;
    error = errfunc;
    evaluate = eval;

    (void)ldef;                 /* placate optimisers */

    sects = NULL;
    sectstail = &sects;

    syms = saa_init((long)sizeof(struct symbol));
    nsyms = 0;

    extsyms = raa_init();
    strs = saa_init(1L);

    /* string table starts with a zero byte - don't ask why */
    saa_wbytes(strs, &zero, sizeof(char));
    strslen = 1;
}

static int macho_setinfo(enum geninfo type, char **val)
{
    return 0;
}

static void sect_write(struct section *sect,
                       const unsigned char *data, unsigned long len)
{
    saa_wbytes(sect->data, data, len);
    sect->size += len;
}

static void add_reloc(struct section *sect, long section,
                      int pcrel, int bytes)
{
    struct reloc *r;
    long fi;

    /* NeXT as puts relocs in reversed order (address-wise) into the
     ** files, so we do the same, doesn't seem to make much of a
     ** difference either way */
    r = nasm_malloc(sizeof(struct reloc));
    r->next = sect->relocs;
    sect->relocs = r;

    /* the current end of the section will be the symbol's address for
     ** now, might have to be fixed by fixup_relocs() later on. make
     ** sure, we don't make the symbol scattered by setting the highest
     ** bit by accident */
    r->addr = sect->size & ~R_SCATTERED;
    r->ext = 0;
    r->pcrel = pcrel;

    /* match byte count 1, 2, 4 to length codes 0, 1, 2 respectively */
    r->length = bytes >> 1;

    /* vanilla relocation (GENERIC_RELOC_VANILLA) */
    r->type = 0;

    if (section == NO_SEG) {
        /* absolute local symbol if no section index given */
        r->snum = R_ABS;
    } else {
        fi = get_section_fileindex_by_index(section);

        if (fi == NO_SECT) {
            /* external symbol if no section with that index known,
             ** symbol number was saved in macho_symdef() */
            r->snum = raa_read(extsyms, section);
            r->ext = 1;
        } else {
            /* local symbol in section fi */
            r->snum = fi;
        }
    }

    ++sect->nreloc;
}

static void macho_output(long secto, const void *data, unsigned long type,
                         long section, long wrt)
{
    struct section *s, *sbss;
    long realbytes = type & OUT_SIZMASK;
    long addr;
    unsigned char mydata[4], *p;

    type &= OUT_TYPMASK;

    if (wrt != NO_SEG) {
        wrt = NO_SEG;
        error(ERR_NONFATAL, "WRT not supported by Mach-O output format");
        /* continue to do _something_ */
    }

    if (secto == NO_SEG) {
        if (type != OUT_RESERVE)
            error(ERR_NONFATAL, "attempt to assemble code in "
                  "[ABSOLUTE] space");

        return;
    }

    s = get_section_by_index(secto);

    if (s == NULL) {
        error(ERR_WARNING, "attempt to assemble code in"
              " section %d: defaulting to `.text'", secto);
        s = get_section_by_name("__TEXT", "__text");

        /* should never happen */
        if (s == NULL)
            error(ERR_PANIC, "text section not found");
    }

    sbss = get_section_by_name("__DATA", "__bss");

    if (s == sbss && type != OUT_RESERVE) {
        error(ERR_WARNING, "attempt to initialise memory in the"
              " BSS section: ignored");

        switch (type) {
        case OUT_REL2ADR:
            realbytes = 2;
            break;

        case OUT_REL4ADR:
            realbytes = 4;
            break;

        default:
            break;
        }

        s->size += realbytes;
        return;
    }

    switch (type) {
    case OUT_RESERVE:
        if (s != sbss) {
            error(ERR_WARNING, "uninitialised space declared in"
                  " %s section: zeroing",
                  get_section_name_by_index(secto));

            sect_write(s, NULL, realbytes);
        } else
            s->size += realbytes;

        break;

    case OUT_RAWDATA:
        if (section != NO_SEG)
            error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");

        sect_write(s, data, realbytes);
        break;

    case OUT_ADDRESS:
        addr = *(long *)data;

        if (section != NO_SEG) {
            if (section % 2) {
                error(ERR_NONFATAL, "Mach-O format does not support"
                      " section base references");
            } else
                add_reloc(s, section, 0, realbytes);
        }

        p = mydata;

        if (realbytes == 2)
            WRITESHORT(p, addr);
        else
            WRITELONG(p, addr);

        sect_write(s, mydata, realbytes);
        break;

    case OUT_REL2ADR:
        if (section == secto)
            error(ERR_PANIC, "intra-section OUT_REL2ADR");

        if (section != NO_SEG && section % 2) {
            error(ERR_NONFATAL, "Mach-O format does not support"
                  " section base references");
        } else
            add_reloc(s, section, 1, 2);

        p = mydata;
        WRITESHORT(p, *(long *)data - (realbytes + s->size));
        sect_write(s, mydata, 2L);
        break;

    case OUT_REL4ADR:
        if (section == secto)
            error(ERR_PANIC, "intra-section OUT_REL4ADR");

        if (section != NO_SEG && section % 2) {
            error(ERR_NONFATAL, "Mach-O format does not support"
                  " section base references");
        } else
            add_reloc(s, section, 1, 4);

        p = mydata;
        WRITELONG(p, *(long *)data - (realbytes + s->size));
        sect_write(s, mydata, 4L);
        break;

    default:
        error(ERR_PANIC, "unknown output type?");
        break;
    }
}

static long macho_section(char *name, int pass, int *bits)
{
    long index;
    struct sectmap *sm;
    struct section *s;

    /* Default to 32 bits. */
    if (!name)
        *bits = 32;

    if (!name)
        name = ".text";

    for (sm = sectmap; sm->nasmsect != NULL; ++sm) {
        /* make lookup into section name translation table */
        if (!strcmp(name, sm->nasmsect)) {
            /* try to find section with that name */
            index = get_section_index_by_name(sm->segname, sm->sectname);

            /* create it if it doesn't exist yet */
            if (index == -1) {
                s = *sectstail = nasm_malloc(sizeof(struct section));
                s->next = NULL;
                sectstail = &s->next;

                s->data = saa_init(1L);
                s->index = seg_alloc();
                s->relocs = NULL;

                xstrncpy(s->segname, sm->segname);
                xstrncpy(s->sectname, sm->sectname);
                s->size = 0;
                s->nreloc = 0;
                s->flags = sm->flags;

                index = s->index;
            }

            return index;
        }
    }

    error(ERR_PANIC, "invalid section name %s", name);
    return NO_SEG;
}

static void macho_symdef(char *name, long section, long offset,
                         int is_global, char *special)
{
    struct symbol *sym;

    if (special) {
        error(ERR_NONFATAL, "The Mach-O output format does "
              "not support any special symbol types");
        return;
    }

    if (is_global == 3) {
        error(ERR_NONFATAL, "The Mach-O format does not "
              "(yet) support forward reference fixups.");
        return;
    }

    sym = saa_wstruct(syms);

    sym->strx = strslen;
    sym->type = 0;
    sym->desc = 0;
    sym->value = offset;

    /* external and common symbols get N_EXT */
    if (is_global != 0)
        sym->type |= N_EXT;

    if (section == NO_SEG) {
        /* symbols in no section get absolute */
        sym->type |= N_ABS;
        sym->sect = NO_SECT;
    } else {
        sym->type |= N_SECT;

        /* get the in-file index of the section the symbol was defined in */
        sym->sect = get_section_fileindex_by_index(section);

        if (sym->sect == NO_SECT) {
            /* remember symbol number of references to external
             ** symbols, this works because every external symbol gets
             ** its own section number allocated internally by nasm and
             ** can so be used as a key */
            extsyms = raa_write(extsyms, section, nsyms);

            switch (is_global) {
            case 1:
            case 2:
                /* there isn't actually a difference between global
                 ** and common symbols, both even have their size in
                 ** sym->value */
                sym->type = N_EXT;
                break;

            default:
                /* give an error on unfound section if it's not an
                 ** external or common symbol (assemble_file() does a
                 ** seg_alloc() on every call for them) */
                error(ERR_PANIC, "in-file index for section %d not found",
                      section);
            }
        }
    }

    /* append symbol name to string table */
    saa_wbytes(strs, name, (long)(strlen(name) + 1));
    strslen += strlen(name) + 1;

    ++nsyms;
}

static long macho_segbase(long section)
{
    return section;
}

static int macho_directive(char *directive, char *value, int pass)
{
    return 0;
}

static void macho_filename(char *inname, char *outname, efunc error)
{
    standard_extension(inname, outname, ".o", error);
}

static const char *macho_stdmac[] = {
    "%define __SECT__ [section .text]",
    "%macro __NASM_CDecl__ 1",
    "%endmacro",
    NULL
};

static void macho_cleanup(int debuginfo)
{
    struct section *s;
    struct reloc *r;
    unsigned long offset, rel_padcnt = 0;
    unsigned long head_ncmds = 0;
    unsigned long head_sizeofcmds = 0;
    unsigned long seg_nsects = 0;
    unsigned long seg_filesize = 0;
    unsigned long seg_vmsize = 0;

    (void)debuginfo;

    /* mach-o object file structure:
     **
     ** mach header
     **  ulong magic
     **  int   cpu type
     **  int   cpu subtype
     **  ulong mach file type
     **  ulong number of load commands
     **  ulong size of all load commands
     **   (includes section struct size of segment command)
     **  ulong flags
     **
     ** segment command
     **  ulong command type == LC_SEGMENT
     **  ulong size of load command
     **   (including section load commands)
     **  char[16] segment name
     **  ulong in-memory offset
     **  ulong in-memory size
     **  ulong in-file offset to data area
     **  ulong in-file size
     **   (in-memory size excluding zerofill sections)
     **  int   maximum vm protection
     **  int   initial vm protection
     **  ulong number of sections
     **  ulong flags
     **
     ** section commands
     **   char[16] section name
     **   char[16] segment name
     **   ulong in-memory offset
     **   ulong in-memory size
     **   ulong in-file offset
     **   ulong alignment
     **    (irrelevant in MH_OBJECT)
     **   ulong in-file offset of relocation entires
     **   ulong number of relocations
     **   ulong flags
     **   ulong reserved
     **   ulong reserved
     **
     ** symbol table command
     **  ulong command type == LC_SYMTAB
     **  ulong size of load command
     **  ulong symbol table offset
     **  ulong number of symbol table entries
     **  ulong string table offset
     **  ulong string table size
     **
     ** raw section data
     **
     ** padding to long boundary
     **
     ** relocation data (struct reloc)
     ** long offset
     **  uint data (symbolnum, pcrel, length, extern, type)
     **
     ** symbol table data (struct nlist)
     **  long  string table entry number
     **  uchar type
     **   (extern, absolute, defined in section)
     **  uchar section
     **   (0 for global symbols, section number of definition (>= 1, <=
     **   254) for local symbols, size of variable for common symbols
     **   [type == extern])
     **  short description
     **   (for stab debugging format)
     **  ulong value (i.e. file offset) of symbol or stab offset
     **
     ** string table data
     **  list of null-terminated strings
     */

    /* simplifications over native NeXTstep assembler:
     ** - no support for dynamic linking/symbols/libraries, section differences
     ** - no sorting of symbols and string table, normally its ordered like
     **  - local symbols, defined external symbols, undefined external symbols
     **  - strings for external symbols, strings for local symbols
     **   we just dump them in the order given by the source file and nasm what
     **   seems to work fine with the link editor
     */

    /* first calculate and finalise all needed values */

    /* count sections and calculate in-memory and in-file offsets */
    for (s = sects; s != NULL; s = s->next) {
        /* zerofill sections aren't actually written to the file */
        if ((s->flags & SECTION_TYPE) != S_ZEROFILL)
            seg_filesize += s->size;

        seg_vmsize += s->size;
        ++seg_nsects;
    }

    /* calculate size of all headers, load commands and sections to
     ** get a pointer to the start of all the raw data */
    if (seg_nsects > 0) {
        ++head_ncmds;
        head_sizeofcmds +=
            MACHO_SEGCMD_SIZE + seg_nsects * MACHO_SECTCMD_SIZE;
    }

    if (nsyms > 0) {
        ++head_ncmds;
        head_sizeofcmds += MACHO_SYMCMD_SIZE;
    }

    /* emit the Mach-O header. */
    fwritelong(MH_MAGIC, machofp);      /* magic */
    fwritelong(CPU_TYPE_I386, machofp); /* CPU type */
    fwritelong(CPU_SUBTYPE_I386_ALL, machofp);  /* CPU subtype */
    fwritelong(MH_OBJECT, machofp);     /* Mach-O file type */
    fwritelong(head_ncmds, machofp);    /* number of load commands */
    fwritelong(head_sizeofcmds, machofp);       /* size of load commands */
    fwritelong(0, machofp);     /* no flags */

    offset = MACHO_HEADER_SIZE + head_sizeofcmds;

    /* emit the segment load command */
    if (seg_nsects > 0) {
        unsigned long s_addr = 0;
        unsigned long rel_base = alignlong(offset + seg_filesize);
        unsigned long s_reloff = 0;

        fwritelong(LC_SEGMENT, machofp);        /* cmd == LC_SEGMENT */

        /* size of load command including section load commands */
        fwritelong(MACHO_SEGCMD_SIZE + seg_nsects *
                   MACHO_SECTCMD_SIZE, machofp);

        /* in an MH_OBJECT file all sections are in one unnamed (name
         ** all zeros) segment */
        fwrite("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 16, 1, machofp);
        fwritelong(0, machofp); /* in-memory offset */
        fwritelong(seg_vmsize, machofp);        /* in-memory size */
        fwritelong(offset, machofp);    /* in-file offset to data */
        fwritelong(seg_filesize, machofp);      /* in-file size */
        fwritelong(VM_PROT_DEFAULT, machofp);   /* maximum vm protection */
        fwritelong(VM_PROT_DEFAULT, machofp);   /* initial vm protection */
        fwritelong(seg_nsects, machofp);        /* number of sections */
        fwritelong(0, machofp); /* no flags */

        /* emit section headers */
        for (s = sects; s != NULL; s = s->next) {
            fwrite(s->sectname, sizeof(s->sectname), 1, machofp);
            fwrite(s->segname, sizeof(s->segname), 1, machofp);
            fwritelong(s_addr, machofp);
            fwritelong(s->size, machofp);

            /* dummy data for zerofill sections or proper values */
            if ((s->flags & SECTION_TYPE) != S_ZEROFILL) {
                fwritelong(offset, machofp);
                fwritelong(0, machofp);
                /* To be compatible with cctools as we emit
                   a zero reloff if we have no relocations.  */
                fwritelong(s->nreloc ? rel_base + s_reloff : 0, machofp);
                fwritelong(s->nreloc, machofp);

                offset += s->size;
                s_reloff += s->nreloc * MACHO_RELINFO_SIZE;
            } else {
                fwritelong(0, machofp);
                fwritelong(0, machofp);
                fwritelong(0, machofp);
                fwritelong(0, machofp);
            }

            fwritelong(s->flags, machofp);      /* flags */
            fwritelong(0, machofp);     /* reserved */
            fwritelong(0, machofp);     /* reserved */

            s_addr += s->size;
        }

        /* at this point offset has reached rel_base - alignment,
         ** remember how much we'll have to pad and skip relocation
         ** data */
        rel_padcnt = rel_base - offset;
        offset = rel_base + s_reloff;
    } else
        error(ERR_WARNING, "no sections?");

    if (nsyms > 0) {
        /* write out symbol command */
        fwritelong(LC_SYMTAB, machofp); /* cmd == LC_SYMTAB */
        fwritelong(MACHO_SYMCMD_SIZE, machofp); /* size of load command */
        fwritelong(offset, machofp);    /* symbol table offset */
        fwritelong(nsyms, machofp);     /* number of symbol
                                         ** table entries */

        offset += nsyms * MACHO_NLIST_SIZE;
        fwritelong(offset, machofp);    /* string table offset */
        fwritelong(strslen, machofp);   /* string table size */
    }

    /* emit section data */
    if (seg_nsects > 0) {
        struct section *s2;
        char *rel_paddata = "\0\0\0";
        unsigned char fi, *p, *q, blk[4];
        long l;

        for (s = sects; s != NULL; s = s->next) {
            if ((s->flags & SECTION_TYPE) == S_ZEROFILL)
                continue;

            /* no padding needs to be done to the sections */

            /* Like a.out Mach-O references things in the data or bss
             * sections by addresses which are actually relative to the
             * start of the _text_ section, in the _file_. See outaout.c
             * for more information. */
            saa_rewind(s->data);
            for (r = s->relocs; r != NULL; r = r->next) {
                saa_fread(s->data, r->addr, blk, (long)r->length << 1);
                p = q = blk;
                l = *p++;

                /* get offset based on relocation type */
                if (r->length > 0) {
                    l += ((long)*p++) << 8;

                    if (r->length == 2) {
                        l += ((long)*p++) << 16;
                        l += ((long)*p++) << 24;
                    }
                }

                /* add sizes of previous sections to current offset */
                for (s2 = sects, fi = 1;
                     s2 != NULL && fi < r->snum; s2 = s2->next, fi++)
                    if ((s2->flags & SECTION_TYPE) != S_ZEROFILL)
                        l += s2->size;

                /* write new offset back */
                if (r->length == 2)
                    WRITELONG(q, l);
                else if (r->length == 1)
                    WRITESHORT(q, l);
                else
                    *q++ = l & 0xFF;

                saa_fwrite(s->data, r->addr, blk, (long)r->length << 1);
            }

            /* dump the section data to file */
            saa_fpwrite(s->data, machofp);
        }

        /* pad last section up to reloc entries on long boundary */
        fwrite(rel_paddata, rel_padcnt, 1, machofp);

        /* emit relocation entries */
        for (s = sects; s != NULL; s = s->next) {
            for (r = s->relocs; r != NULL; r = r->next) {
                unsigned long word2;

                fwritelong(r->addr, machofp);   /* reloc offset */

                word2 = r->snum;
                word2 |= r->pcrel << 24;
                word2 |= r->length << 25;
                word2 |= r->ext << 27;
                word2 |= r->type << 28;
                fwritelong(word2, machofp);     /* reloc data */
            }
        }
    }

    /* emit symbol table */
    if (nsyms > 0) {
        struct symbol *sym;
        long fi, i;

        /* we don't need to pad here since MACHO_RELINFO_SIZE == 8 */

        saa_rewind(syms);
        for (i = 0; i < nsyms; ++i) {
            sym = saa_rstruct(syms);

            fwritelong(sym->strx, machofp);     /* string table entry number */
            fwrite(&sym->type, 1, 1, machofp);  /* symbol type */
            fwrite(&sym->sect, 1, 1, machofp);  /* section */
            fwriteshort(sym->desc, machofp);    /* description */

            /* fix up the symbol value now we know the final section
             ** sizes. */
            if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
                for (s = sects, fi = 1;
                     s != NULL && fi < sym->sect; s = s->next, ++fi)
                    sym->value += s->size;
            }

            fwritelong(sym->value, machofp);    /* value (i.e. offset) */
        }
    }

    /* we don't need to pad here since MACHO_NLIST_SIZE == 12 */

    /* emit string table */
    saa_fpwrite(strs, machofp);

    /* done - yay! */
    fclose(machofp);

    /* free up everything */
    while (sects->next) {
        s = sects;
        sects = sects->next;

        saa_free(s->data);
        while (s->relocs != NULL) {
            r = s->relocs;
            s->relocs = s->relocs->next;
            nasm_free(r);
        }

        nasm_free(s);
    }

    saa_free(strs);
    raa_free(extsyms);
    saa_free(syms);
}

struct ofmt of_macho = {
    "NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X object files",
    "macho",
    NULL,
    null_debug_arr,
    &null_debug_form,
    macho_stdmac,
    macho_init,
    macho_setinfo,
    macho_output,
    macho_symdef,
    macho_section,
    macho_segbase,
    macho_directive,
    macho_filename,
    macho_cleanup
};

#endif

/*
 * Local Variables:
 * mode:c
 * c-basic-offset:4
 * End:
 *
 * end of file */