summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Makefile.in17
-rw-r--r--output/outform.h31
-rw-r--r--output/outmacho.mac2
-rw-r--r--output/outmacho32.c (renamed from output/outmacho.c)36
-rw-r--r--output/outmacho64.c1533
5 files changed, 1594 insertions, 25 deletions
diff --git a/Makefile.in b/Makefile.in
index 92f9192..5bb73b2 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -67,10 +67,10 @@ NASM = nasm.$(O) nasmlib.$(O) ver.$(O) \
output/outbin.$(O) output/outaout.$(O) output/outcoff.$(O) \
output/outelf.$(O) output/outelf32.$(O) output/outelf64.$(O) \
output/outobj.$(O) output/outas86.$(O) output/outrdf2.$(O) \
- output/outdbg.$(O) output/outieee.$(O) output/outmacho.$(O) \
- preproc.$(O) quote.$(O) pptok.$(O) macros.$(O) \
- listing.$(O) eval.$(O) exprlib.$(O) stdscan.$(O) strfunc.$(O) \
- tokhash.$(O) regvals.$(O) regflags.$(O)
+ output/outdbg.$(O) output/outieee.$(O) output/outmacho32.$(O) \
+ output/outmacho64.$(O) preproc.$(O) quote.$(O) pptok.$(O) \
+ macros.$(O) listing.$(O) eval.$(O) exprlib.$(O) stdscan.$(O) \
+ strfunc.$(O) tokhash.$(O) regvals.$(O) regflags.$(O)
NDISASM = ndisasm.$(O) disasm.$(O) sync.$(O) nasmlib.$(O) ver.$(O) \
insnsd.$(O) insnsb.$(O) insnsn.$(O) regs.$(O) regdis.$(O)
@@ -312,9 +312,12 @@ output/outieee.$(O): output/outieee.c compiler.h config.h insnsi.h nasm.h \
nasmlib.h output/outform.h output/outlib.h pptok.h preproc.h regs.h
output/outlib.$(O): output/outlib.c compiler.h config.h insnsi.h nasm.h \
nasmlib.h output/outlib.h pptok.h preproc.h regs.h
-output/outmacho.$(O): output/outmacho.c compiler.h config.h insnsi.h nasm.h \
- nasmlib.h output/outform.h output/outlib.h pptok.h preproc.h raa.h regs.h \
- saa.h
+output/outmacho32.$(O): output/outmacho32.c compiler.h config.h insnsi.h \
+ nasm.h nasmlib.h output/outform.h output/outlib.h pptok.h preproc.h raa.h \
+ regs.h saa.h
+output/outmacho64.$(O): output/outmacho64.c compiler.h config.h insnsi.h \
+ nasm.h nasmlib.h output/outform.h output/outlib.h pptok.h preproc.h raa.h \
+ regs.h saa.h
output/outobj.$(O): output/outobj.c compiler.h config.h insnsi.h nasm.h \
nasmlib.h output/outform.h output/outlib.h pptok.h preproc.h regs.h \
stdscan.h
diff --git a/output/outform.h b/output/outform.h
index e96a4b9..3dfbc9c 100644
--- a/output/outform.h
+++ b/output/outform.h
@@ -133,8 +133,11 @@
#ifndef OF_IEEE
#define OF_IEEE
#endif
-#ifndef OF_MACHO
-#define OF_MACHO
+#ifndef OF_MACHO32
+#define OF_MACHO32
+#endif
+#ifndef OF_MACHO64
+#define OF_MACHO64
#endif
#ifndef OF_DBG
#define OF_DBG
@@ -191,8 +194,11 @@
#ifndef OF_IEEE
#define OF_IEEE
#endif
-#ifndef OF_MACHO
-#define OF_MACHO
+#ifndef OF_MACHO32
+#define OF_MACHO32
+#endif
+#ifndef OF_MACHO64
+#define OF_MACHO64
#endif
#endif
@@ -233,8 +239,11 @@
#ifdef OF_NO_IEEE
#undef OF_IEEE
#endif
-#ifdef OF_NO_MACHO
-#undef OF_MACHO
+#ifdef OF_NO_MACHO32
+#undef OF_MACHO32
+#endif
+#ifdef OF_NO_MACHO64
+#undef OF_MACHO64
#endif
#ifdef OF_NO_DBG
#undef OF_DBG
@@ -264,7 +273,9 @@ extern struct ofmt of_win32;
extern struct ofmt of_win64;
extern struct ofmt of_rdf2;
extern struct ofmt of_ieee;
+extern struct ofmt of_macho32;
extern struct ofmt of_macho;
+extern struct ofmt of_macho64;
extern struct ofmt of_dbg;
struct ofmt *drivers[] = {
@@ -307,8 +318,12 @@ struct ofmt *drivers[] = {
#ifdef OF_IEEE
&of_ieee,
#endif
-#ifdef OF_MACHO
- &of_macho,
+#ifdef OF_MACHO32
+ &of_macho32,
+ &of_macho,
+#endif
+#ifdef OF_MACHO64
+ &of_macho64,
#endif
#ifdef OF_DBG
&of_dbg,
diff --git a/output/outmacho.mac b/output/outmacho.mac
index f86c308..f1cdf18 100644
--- a/output/outmacho.mac
+++ b/output/outmacho.mac
@@ -31,7 +31,7 @@
;;
;; --------------------------------------------------------------------------
-OUT: macho
+OUT: macho macho32 macho64
%define __SECT__ [section .text]
%macro __NASM_CDecl__ 1
%endmacro
diff --git a/output/outmacho.c b/output/outmacho32.c
index 7e2f0fb..c9e4365 100644
--- a/output/outmacho.c
+++ b/output/outmacho32.c
@@ -54,7 +54,7 @@
#include "output/outform.h"
#include "output/outlib.h"
-#if defined(OF_MACHO)
+#if defined(OF_MACHO32)
/* Mach-O in-file header structure sizes */
#define MACHO_HEADER_SIZE (28)
@@ -1020,13 +1020,13 @@ static void macho_write_section (void)
of the rest of the address. */
if (!r->ext) {
/* generate final address by section address and offset */
- for (s2 = sects, fi = 1;
- s2 != NULL; s2 = s2->next, fi++){
- if(fi == r->snum){
- l += s2->addr;
- break;
- }
- }
+ for (s2 = sects, fi = 1;
+ s2 != NULL; s2 = s2->next, fi++) {
+ if (fi == r->snum) {
+ l += s2->addr;
+ break;
+ }
+ }
}
/* write new offset back */
@@ -1335,8 +1335,26 @@ static void debug_section_relocs (struct section *s)
}
}
+struct ofmt of_macho32 = {
+ "NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X (i386) object files",
+ "macho32",
+ 0,
+ 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
+};
+
struct ofmt of_macho = {
- "NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X object files",
+ "MACHO (short name for MACHO32)",
"macho",
0,
null_debug_arr,
diff --git a/output/outmacho64.c b/output/outmacho64.c
new file mode 100644
index 0000000..cad399d
--- /dev/null
+++ b/output/outmacho64.c
@@ -0,0 +1,1533 @@
+/* ----------------------------------------------------------------------- *
+ *
+ * Copyright 1996-2009 The NASM Authors - All Rights Reserved
+ * See the file AUTHORS included with the NASM distribution for
+ * the specific copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * outmacho64.c output routines for the Netwide Assembler to produce
+ * NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X (x86_64) object files
+ */
+
+/* Most of this file is, like Mach-O itself, based on a.out. For more
+ * guidelines see outaout.c. */
+
+#include "compiler.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <inttypes.h>
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "saa.h"
+#include "raa.h"
+#include "output/outform.h"
+#include "output/outlib.h"
+
+#if defined(OF_MACHO64)
+
+/* Mach-O in-file header structure sizes */
+#define MACHO_HEADER64_SIZE (32)
+#define MACHO_SEGCMD64_SIZE (72)
+#define MACHO_SECTCMD64_SIZE (80)
+#define MACHO_SYMCMD_SIZE (24)
+#define MACHO_NLIST64_SIZE (16)
+#define MACHO_RELINFO64_SIZE (8)
+
+/* Mach-O file header values */
+#define MH_MAGIC_64 (0xfeedfacf)
+#define CPU_TYPE_X86_64 (0x01000007) /* x86-64 platform */
+#define CPU_SUBTYPE_I386_ALL (3) /* all-x86 compatible */
+#define MH_OBJECT (0x1) /* object file */
+
+#define LC_SEGMENT_64 (0x19) /* 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;
+ int32_t index;
+ struct reloc *relocs;
+ int align;
+
+ /* data that goes into the file */
+ char sectname[16]; /* what this section is called */
+ char segname[16]; /* segment this section will be in */
+ uint64_t addr; /* in-memory address (subject to alignment) */
+ uint64_t size; /* in-memory and -file size */
+ uint32_t nreloc; /* relocation entry count */
+ uint32_t flags; /* type and attributes (masked) */
+ uint32_t extreloc; /* external relocations */
+};
+
+#define SECTION_TYPE 0x000000ff /* section type mask */
+
+#define S_REGULAR (0x0) /* standard section */
+#define S_ZEROFILL (0x1) /* zerofill, in-memory only */
+
+#define SECTION_ATTRIBUTES_SYS 0x00ffff00 /* system setable attributes */
+#define S_ATTR_SOME_INSTRUCTIONS 0x00000400 /* section contains some
+ machine instructions */
+#define S_ATTR_EXT_RELOC 0x00000200 /* section has external
+ relocation entries */
+#define S_ATTR_LOC_RELOC 0x00000100 /* section has local
+ relocation entries */
+#define S_ATTR_PURE_INSTRUCTIONS 0x80000000 /* section uses pure
+ machine instructions */
+
+static struct sectmap {
+ const char *nasmsect;
+ const char *segname;
+ const char *sectname;
+ const int32_t flags;
+} sectmap[] = {
+ {".text", "__TEXT", "__text", S_REGULAR|S_ATTR_SOME_INSTRUCTIONS|S_ATTR_PURE_INSTRUCTIONS},
+ {".data", "__DATA", "__data", S_REGULAR},
+ {".rodata", "__DATA", "__const", S_REGULAR},
+ {".bss", "__DATA", "__bss", S_ZEROFILL},
+ {NULL, NULL, NULL, 0}
+};
+
+struct reloc {
+ /* nasm internal data */
+ struct reloc *next;
+
+ /* data that goes into the file */
+ int32_t addr; /* op's offset in section */
+ uint32_t snum:24, /* contains symbol index if
+ ** ext otherwise in-file
+ ** section number */
+ pcrel:1, /* relative relocation */
+ length:2, /* 0=byte, 1=word, 2=int32_t, 3=int64_t */
+ ext:1, /* external symbol referenced */
+ type:4; /* reloc type */
+};
+
+#define R_ABS 0 /* absolute relocation */
+#define R_SCATTERED 0x80000000 /* reloc entry is scattered if
+ ** highest bit == 1 */
+
+struct symbol {
+ /* nasm internal data */
+ struct symbol *next; /* next symbol in the list */
+ char *name; /* name of this symbol */
+ int32_t initial_snum; /* symbol number used above in
+ reloc */
+ int32_t snum; /* true snum for reloc */
+
+ /* data that goes into the file */
+ uint32_t strx; /* string table index */
+ uint8_t type; /* symbol type */
+ uint8_t sect; /* NO_SECT or section number */
+ uint16_t desc; /* for stab debugging, 0 for us */
+ uint64_t 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 */
+
+#define DEFAULT_SECTION_ALIGNMENT 0 /* byte (i.e. no) alignment */
+
+/* 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 symbol *syms, **symstail;
+static uint32_t nsyms;
+
+/* These variables are set by macho_layout_symbols() to organize
+ the symbol table and string table in order the dynamic linker
+ expects. They are then used in macho_write() to put out the
+ symbols and strings in that order.
+
+ The order of the symbol table is:
+ local symbols
+ defined external symbols (sorted by name)
+ undefined external symbols (sorted by name)
+
+ The order of the string table is:
+ strings for external symbols
+ strings for local symbols
+ */
+static uint32_t ilocalsym = 0;
+static uint32_t iextdefsym = 0;
+static uint32_t iundefsym = 0;
+static uint32_t nlocalsym;
+static uint32_t nextdefsym;
+static uint32_t nundefsym;
+static struct symbol **extdefsyms = NULL;
+static struct symbol **undefsyms = NULL;
+
+static struct RAA *extsyms;
+static struct SAA *strs;
+static uint32_t strslen;
+
+static FILE *machofp;
+static efunc error;
+static evalfunc evaluate;
+
+extern struct ofmt of_macho64;
+
+/* Global file information. This should be cleaned up into either
+ a structure or as function arguments. */
+uint32_t head_ncmds64 = 0;
+uint32_t head_sizeofcmds64 = 0;
+uint64_t seg_filesize64 = 0;
+uint64_t seg_vmsize64 = 0;
+uint32_t seg_nsects64 = 0;
+uint64_t rel_padcnt64 = 0;
+
+
+#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 alignint32_t(x) \
+ align(x, sizeof(int32_t)) /* align x to int32_t boundary */
+
+#define alignint64_t(x) \
+ align(x, sizeof(int64_t)) /* align x to int64_t boundary */
+
+static void debug_reloc (struct reloc *);
+static void debug_section_relocs (struct section *) _unused;
+
+static int exact_log2 (uint32_t align)
+{
+ if (align == 0) {
+ return 0;
+ } else if (align & (align-1)) {
+ return -1; /* Not a power of 2 */
+ } else {
+#ifdef HAVE_GNUC_4
+ return __builtin_ctzl (align);
+#else
+ uint32_t result = 0;
+
+ /* We know exactly one bit is set at this point. */
+ if (align & 0xffff0000)
+ result |= 16;
+ if (align & 0xff00ff00)
+ result |= 8;
+ if (align & 0xf0f0f0f0)
+ result |= 4;
+ if (align & 0xcccccccc)
+ result |= 2;
+ if (align & 0xaaaaaaaa)
+ result |= 1;
+
+ return result;
+#endif
+ }
+}
+
+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 int32_t index)
+{
+ struct section *s;
+
+ for (s = sects; s != NULL; s = s->next)
+ if (index == s->index)
+ break;
+
+ return s;
+}
+
+static int32_t 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 int32_t index)
+{
+ struct section *s;
+
+ for (s = sects; s != NULL; s = s->next)
+ if (index == s->index)
+ return s->sectname;
+
+ return NULL;
+}
+
+static uint8_t get_section_fileindex_by_index(const int32_t index)
+{
+ struct section *s;
+ uint8_t 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 struct symbol *get_closest_section_symbol_by_offset(uint8_t fileindex, int64_t offset)
+{
+ struct symbol *sym;
+
+ for (sym = syms; sym != NULL; sym = sym->next) {
+ if ((sym->sect != NO_SECT) &&
+ (sym->sect == fileindex) &&
+ ((int64_t)sym->value >= offset))
+ return sym;
+ }
+
+ return NULL;
+}
+
+
+/*
+ * Special section numbers which are used to define Mach-O special
+ * symbols, which can be used with WRT to provide PIC relocation
+ * types.
+ */
+static int32_t macho_gotpcrel_sect;
+
+static void macho_init(FILE * fp, efunc errfunc, ldfunc ldef,
+ evalfunc eval)
+{
+ char zero = 0;
+
+ maxbits = 64;
+ machofp = fp;
+ error = errfunc;
+ evaluate = eval;
+
+ (void)ldef; /* placate optimizers */
+
+ sects = NULL;
+ sectstail = &sects;
+
+ syms = NULL;
+ symstail = &syms;
+ nsyms = 0;
+ nlocalsym = 0;
+ nextdefsym = 0;
+ nundefsym = 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;
+
+ /* add special symbol for ..gotpcrel */
+ macho_gotpcrel_sect = seg_alloc();
+ macho_gotpcrel_sect ++;
+ ldef("..gotpcrel", macho_gotpcrel_sect, 0L, NULL, false, false, &of_macho64, error);
+}
+
+static int macho_setinfo(enum geninfo type, char **val)
+{
+ (void)type;
+ (void)val;
+ return 0;
+}
+
+static void sect_write(struct section *sect,
+ const uint8_t *data, uint32_t len)
+{
+ saa_wbytes(sect->data, data, len);
+ sect->size += len;
+}
+
+static int32_t add_reloc(struct section *sect, int32_t section,
+ int pcrel, int bytes, int64_t reloff)
+{
+ struct reloc *r;
+ struct symbol *sym;
+ int32_t fi;
+ int32_t adjustment = 0;
+
+ /* 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 macho_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 = 1;
+ r->pcrel = (pcrel ? 1 : 0);
+
+ /* match byte count 1, 2, 4, 8 to length codes 0, 1, 2, 3 respectively */
+ switch(bytes){
+ case 1:
+ r->length = 0;
+ break;
+ case 2:
+ r->length = 1;
+ break;
+ case 4:
+ r->length = 2;
+ break;
+ case 8:
+ r->length = 3;
+ break;
+ default:
+ break;
+ }
+
+ /* set default relocation values */
+ r->type = 0; // X86_64_RELOC_UNSIGNED
+ r->snum = R_ABS; // Absolute Symbol (indicates no relocation)
+
+ /* absolute relocation */
+ if (pcrel == 0) {
+
+ /* intra-section */
+ if (section == NO_SEG) {
+ // r->snum = R_ABS; // Set above
+
+ /* inter-section */
+ } else {
+ fi = get_section_fileindex_by_index(section);
+
+ /* external */
+ if (fi == NO_SECT) {
+ r->snum = raa_read(extsyms, section);
+
+ /* local */
+ } else {
+ sym = get_closest_section_symbol_by_offset(fi, reloff);
+ r->snum = sym->initial_snum;
+ adjustment = sym->value;
+ }
+ }
+
+ /* relative relocation */
+ } else if (pcrel == 1) {
+
+ /* intra-section */
+ if (section == NO_SEG) {
+ r->type = 1; // X86_64_RELOC_SIGNED
+
+ /* inter-section */
+ } else {
+ r->type = 2; // X86_64_RELOC_BRANCH
+ fi = get_section_fileindex_by_index(section);
+
+ /* external */
+ if (fi == NO_SECT) {
+ sect->extreloc = 1;
+ r->snum = raa_read(extsyms, section);
+
+ /* local */
+ } else {
+ sym = get_closest_section_symbol_by_offset(fi, reloff);
+ r->snum = sym->initial_snum;
+ adjustment = sym->value;
+ }
+ }
+
+ /* subtractor */
+ } else if (pcrel == 2) {
+ r->pcrel = 0;
+ r->type = 5; // X86_64_RELOC_SUBTRACTOR
+
+ /* gotpcrel */
+ } else if (pcrel == 3) {
+ r->type = 4; // X86_64_RELOC_GOT
+ r->snum = macho_gotpcrel_sect;
+
+ /* gotpcrel MOVQ load */
+ } else if (pcrel == 4) {
+ r->type = 3; // X86_64_RELOC_GOT_LOAD
+ r->snum = macho_gotpcrel_sect;
+ }
+
+ ++sect->nreloc;
+
+ return adjustment;
+}
+
+static void macho_output(int32_t secto, const void *data,
+ enum out_type type, uint64_t size,
+ int32_t section, int32_t wrt)
+{
+ struct section *s, *sbss;
+ int64_t addr;
+ uint8_t mydata[16], *p, gotload;
+
+ 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 initialize memory in the"
+ " BSS section: ignored");
+ s->size += realsize(type, size);
+ return;
+ }
+
+ switch (type) {
+ case OUT_RESERVE:
+ if (s != sbss) {
+ error(ERR_WARNING, "uninitialized space declared in"
+ " %s section: zeroing",
+ get_section_name_by_index(secto));
+
+ sect_write(s, NULL, size);
+ } else
+ s->size += size;
+
+ break;
+
+ case OUT_RAWDATA:
+ if (section != NO_SEG)
+ error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
+
+ sect_write(s, data, size);
+ break;
+
+ case OUT_ADDRESS:
+ addr = *(int64_t *)data;
+ if (section != NO_SEG) {
+ if (section % 2) {
+ error(ERR_NONFATAL, "Mach-O format does not support"
+ " section base references");
+ } else {
+ if (wrt == NO_SEG) {
+ if (size < 8) {
+ error(ERR_NONFATAL, "Mach-O 64-bit format does not support"
+ " 32-bit absolute addresses");
+ /*
+ Seemingly, Mach-O's X86_64_RELOC_SUBTRACTOR would require
+ pre-determined knowledge of where the image base would be,
+ making it impractical for use in intermediate object files
+ */
+ } else {
+ addr -= add_reloc(s, section, 0, size, addr); // X86_64_RELOC_UNSIGNED
+ }
+ } else {
+ error(ERR_NONFATAL, "Mach-O format does not support"
+ " this use of WRT");
+ }
+ }
+ }
+
+ p = mydata;
+ WRITEADDR(p, addr, size);
+ sect_write(s, mydata, size);
+ break;
+
+ case OUT_REL2ADR:
+ p = mydata;
+ WRITESHORT(p, *(int64_t *)data);
+
+ if (section == secto)
+ error(ERR_PANIC, "intra-section OUT_REL2ADR");
+
+ if (section == NO_SEG) {
+ /* Do nothing */
+ } else if (section % 2) {
+ error(ERR_NONFATAL, "Mach-O format does not support"
+ " section base references");
+ } else {
+ error(ERR_NONFATAL, "Unsupported non-32-bit"
+ " Macho-O relocation [2]");
+ }
+
+ sect_write(s, mydata, 2L);
+ break;
+
+ case OUT_REL4ADR:
+ p = mydata;
+ WRITELONG(p, *(int64_t *)data);
+
+ 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 {
+ if (wrt == NO_SEG) {
+ *mydata -= add_reloc(s, section, 1, 4, (int64_t)*mydata); // X86_64_RELOC_SIGNED/BRANCH
+ } else if (wrt == macho_gotpcrel_sect) {
+ if (s->data->datalen > 1) {
+ saa_fread(s->data, s->data->datalen-2, &gotload, 1); // Retrieve Instruction Opcode
+ } else {
+ gotload = 0;
+ }
+ if (gotload == 0x8B) { // Check for MOVQ Opcode
+ *mydata -= add_reloc(s, section, 4, 4, (int64_t)*mydata); // X86_64_GOT_LOAD (MOVQ load)
+ } else {
+ *mydata -= add_reloc(s, section, 3, 4, (int64_t)*mydata); // X86_64_GOT
+ }
+ } else {
+ error(ERR_NONFATAL, "Mach-O format does not support"
+ " this use of WRT");
+ wrt = NO_SEG; /* we can at least _try_ to continue */
+ }
+ }
+
+ sect_write(s, mydata, 4L);
+ break;
+
+ default:
+ error(ERR_PANIC, "unknown output type?");
+ break;
+ }
+}
+
+static int32_t macho_section(char *name, int pass, int *bits)
+{
+ int32_t index, originalIndex;
+ char *sectionAttributes;
+ struct sectmap *sm;
+ struct section *s;
+
+ (void)pass;
+
+ /* Default to 64 bits. */
+ if (!name) {
+ *bits = 64;
+ name = ".text";
+ sectionAttributes = NULL;
+ } else {
+ sectionAttributes = name;
+ name = nasm_strsep(&sectionAttributes, " \t");
+ }
+
+ for (sm = sectmap; sm->nasmsect != NULL; ++sm) {
+ /* make lookup into section name translation table */
+ if (!strcmp(name, sm->nasmsect)) {
+ char *currentAttribute;
+
+ /* try to find section with that name */
+ originalIndex = 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;
+ s->align = -1;
+
+ xstrncpy(s->segname, sm->segname);
+ xstrncpy(s->sectname, sm->sectname);
+ s->size = 0;
+ s->nreloc = 0;
+ s->flags = sm->flags;
+
+ index = s->index;
+ } else {
+ s = get_section_by_index(index);
+ }
+
+ while ((NULL != sectionAttributes)
+ && (currentAttribute = nasm_strsep(&sectionAttributes, " \t"))) {
+ if (0 != *currentAttribute) {
+ if (!nasm_strnicmp("align=", currentAttribute, 6)) {
+ char *end;
+ int newAlignment, value;
+
+ value = strtoul(currentAttribute + 6, (char**)&end, 0);
+ newAlignment = exact_log2(value);
+
+ if (0 != *end) {
+ error(ERR_PANIC,
+ "unknown or missing alignment value \"%s\" "
+ "specified for section \"%s\"",
+ currentAttribute + 6,
+ name);
+ return NO_SEG;
+ } else if (0 > newAlignment) {
+ error(ERR_PANIC,
+ "alignment of %d (for section \"%s\") is not "
+ "a power of two",
+ value,
+ name);
+ return NO_SEG;
+ }
+
+ if ((-1 != originalIndex)
+ && (s->align != newAlignment)
+ && (s->align != -1)) {
+ error(ERR_PANIC,
+ "section \"%s\" has already been specified "
+ "with alignment %d, conflicts with new "
+ "alignment of %d",
+ name,
+ (1 << s->align),
+ value);
+ return NO_SEG;
+ }
+
+ s->align = newAlignment;
+ } else if (!nasm_stricmp("data", currentAttribute)) {
+ /* Do nothing; 'data' is implicit */
+ } else {
+ error(ERR_PANIC,
+ "unknown section attribute %s for section %s",
+ currentAttribute,
+ name);
+ return NO_SEG;
+ }
+ }
+ }
+
+ return index;
+ }
+ }
+
+ error(ERR_PANIC, "invalid section name %s", name);
+ return NO_SEG;
+}
+
+static void macho_symdef(char *name, int32_t section, int64_t 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;
+ }
+
+ if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
+ /*
+ * This is a NASM special symbol. We never allow it into
+ * the Macho-O symbol table, even if it's a valid one. If it
+ * _isn't_ a valid one, we should barf immediately.
+ */
+ if (strcmp(name, "..gotpcrel"))
+ error(ERR_NONFATAL, "unrecognized special symbol `%s'", name);
+ return;
+ }
+
+ sym = *symstail = nasm_malloc(sizeof(struct symbol));
+ sym->next = NULL;
+ symstail = &sym->next;
+
+ sym->name = name;
+ sym->strx = strslen;
+ sym->type = 0;
+ sym->desc = 0;
+ sym->value = offset;
+ sym->initial_snum = -1;
+
+ /* 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);
+
+ /* track the initially allocated symbol number for use in future fix-ups */
+ sym->initial_snum = nsyms;
+
+ 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);
+ }
+ }
+ }
+ ++nsyms;
+}
+
+static int32_t macho_segbase(int32_t section)
+{
+ return section;
+}
+
+static int macho_directive(char *directive, char *value, int pass)
+{
+ (void)directive;
+ (void)value;
+ (void)pass;
+ return 0;
+}
+
+static void macho_filename(char *inname, char *outname, efunc error)
+{
+ standard_extension(inname, outname, ".o", error);
+}
+
+extern macros_t macho_stdmac[];
+
+/* Comparison function for qsort symbol layout. */
+static int layout_compare (const struct symbol **s1,
+ const struct symbol **s2)
+{
+ return (strcmp ((*s1)->name, (*s2)->name));
+}
+
+/* The native assembler does a few things in a similar function
+
+ * Remove temporary labels
+ * Sort symbols according to local, external, undefined (by name)
+ * Order the string table
+
+ We do not remove temporary labels right now.
+
+ numsyms is the total number of symbols we have. strtabsize is the
+ number entries in the string table. */
+
+static void macho_layout_symbols (uint32_t *numsyms,
+ uint32_t *strtabsize)
+{
+ struct symbol *sym, **symp;
+ uint32_t i,j;
+
+ *numsyms = 0;
+ *strtabsize = sizeof (char);
+
+ symp = &syms;
+
+ while ((sym = *symp)) {
+ /* Undefined symbols are now external. */
+ if (sym->type == N_UNDF)
+ sym->type |= N_EXT;
+
+ if ((sym->type & N_EXT) == 0) {
+ sym->snum = *numsyms;
+ *numsyms = *numsyms + 1;
+ nlocalsym++;
+ }
+ else {
+ if ((sym->type & N_TYPE) != N_UNDF) {
+ nextdefsym++;
+ } else {
+ nundefsym++;
+ }
+
+ /* If we handle debug info we'll want
+ to check for it here instead of just
+ adding the symbol to the string table. */
+ sym->strx = *strtabsize;
+ saa_wbytes (strs, sym->name, (int32_t)(strlen(sym->name) + 1));
+ *strtabsize += strlen(sym->name) + 1;
+ }
+ symp = &(sym->next);
+ }
+
+ /* Next, sort the symbols. Most of this code is a direct translation from
+ the Apple cctools symbol layout. We need to keep compatibility with that. */
+ /* Set the indexes for symbol groups into the symbol table */
+ ilocalsym = 0;
+ iextdefsym = nlocalsym;
+ iundefsym = nlocalsym + nextdefsym;
+
+ /* allocate arrays for sorting externals by name */
+ extdefsyms = nasm_malloc(nextdefsym * sizeof(struct symbol *));
+ undefsyms = nasm_malloc(nundefsym * sizeof(struct symbol *));
+
+ i = 0;
+ j = 0;
+
+ symp = &syms;
+
+ while ((sym = *symp)) {
+
+ if((sym->type & N_EXT) == 0) {
+ sym->strx = *strtabsize;
+ saa_wbytes (strs, sym->name, (int32_t)(strlen (sym->name) + 1));
+ *strtabsize += strlen(sym->name) + 1;
+ }
+ else {
+ if((sym->type & N_TYPE) != N_UNDF) {
+ extdefsyms[i++] = sym;
+ } else {
+ undefsyms[j++] = sym;
+ }
+ }
+ symp = &(sym->next);
+ }
+
+ qsort(extdefsyms, nextdefsym, sizeof(struct symbol *),
+ (int (*)(const void *, const void *))layout_compare);
+ qsort(undefsyms, nundefsym, sizeof(struct symbol *),
+ (int (*)(const void *, const void *))layout_compare);
+
+ for(i = 0; i < nextdefsym; i++) {
+ extdefsyms[i]->snum = *numsyms;
+ *numsyms += 1;
+ }
+ for(j = 0; j < nundefsym; j++) {
+ undefsyms[j]->snum = *numsyms;
+ *numsyms += 1;
+ }
+}
+
+/* Calculate some values we'll need for writing later. */
+
+static void macho_calculate_sizes (void)
+{
+ struct section *s;
+
+ /* count sections and calculate in-memory and in-file offsets */
+ for (s = sects; s != NULL; s = s->next) {
+ uint64_t pad = 0;
+
+ /* zerofill sections aren't actually written to the file */
+ if ((s->flags & SECTION_TYPE) != S_ZEROFILL)
+ seg_filesize64 += s->size;
+
+ /* recalculate segment address based on alignment and vm size */
+ s->addr = seg_vmsize64;
+ /* we need section alignment to calculate final section address */
+ if (s->align == -1)
+ s->align = DEFAULT_SECTION_ALIGNMENT;
+ if(s->align) {
+ uint64_t newaddr = align(s->addr, 1 << s->align);
+ pad = newaddr - s->addr;
+ s->addr = newaddr;
+ }
+
+ seg_vmsize64 += s->size + pad;
+ ++seg_nsects64;
+ }
+
+ /* calculate size of all headers, load commands and sections to
+ ** get a pointer to the start of all the raw data */
+ if (seg_nsects64 > 0) {
+ ++head_ncmds64;
+ head_sizeofcmds64 +=
+ MACHO_SEGCMD64_SIZE + seg_nsects64 * MACHO_SECTCMD64_SIZE;
+ }
+
+ if (nsyms > 0) {
+ ++head_ncmds64;
+ head_sizeofcmds64 += MACHO_SYMCMD_SIZE;
+ }
+}
+
+/* Write out the header information for the file. */
+
+static void macho_write_header (void)
+{
+ fwriteint32_t(MH_MAGIC_64, machofp); /* magic */
+ fwriteint32_t(CPU_TYPE_X86_64, machofp); /* CPU type */
+ fwriteint32_t(CPU_SUBTYPE_I386_ALL, machofp); /* CPU subtype */
+ fwriteint32_t(MH_OBJECT, machofp); /* Mach-O file type */
+ fwriteint32_t(head_ncmds64, machofp); /* number of load commands */
+ fwriteint32_t(head_sizeofcmds64, machofp); /* size of load commands */
+ fwriteint32_t(0, machofp); /* no flags */
+ fwriteint32_t(0, machofp); /* reserved for future use */
+}
+
+/* Write out the segment load command at offset. */
+
+static uint32_t macho_write_segment (uint64_t offset)
+{
+ uint64_t rel_base = alignint64_t (offset + seg_filesize64);
+ uint32_t s_reloff = 0;
+ struct section *s;
+
+ fwriteint32_t(LC_SEGMENT_64, machofp); /* cmd == LC_SEGMENT_64 */
+
+ /* size of load command including section load commands */
+ fwriteint32_t(MACHO_SEGCMD64_SIZE + seg_nsects64 *
+ MACHO_SECTCMD64_SIZE, machofp);
+
+ /* in an MH_OBJECT file all sections are in one unnamed (name
+ ** all zeros) segment */
+ fwritezero(16, machofp);
+ fwriteint64_t(0, machofp); /* in-memory offset */
+ fwriteint64_t(seg_vmsize64, machofp); /* in-memory size */
+ fwriteint64_t(offset, machofp); /* in-file offset to data */
+ fwriteint64_t(seg_filesize64, machofp); /* in-file size */
+ fwriteint32_t(VM_PROT_DEFAULT, machofp); /* maximum vm protection */
+ fwriteint32_t(VM_PROT_DEFAULT, machofp); /* initial vm protection */
+ fwriteint32_t(seg_nsects64, machofp); /* number of sections */
+ fwriteint32_t(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);
+ fwriteint64_t(s->addr, machofp);
+ fwriteint64_t(s->size, machofp);
+
+ /* dummy data for zerofill sections or proper values */
+ if ((s->flags & SECTION_TYPE) != S_ZEROFILL) {
+ fwriteint32_t(offset, machofp);
+ /* Write out section alignment, as a power of two.
+ e.g. 32-bit word alignment would be 2 (2^2 = 4). */
+ if (s->align == -1)
+ s->align = DEFAULT_SECTION_ALIGNMENT;
+ fwriteint32_t(s->align, machofp);
+ /* To be compatible with cctools as we emit
+ a zero reloff if we have no relocations. */
+ fwriteint32_t(s->nreloc ? rel_base + s_reloff : 0, machofp);
+ fwriteint32_t(s->nreloc, machofp);
+
+ offset += s->size;
+ s_reloff += s->nreloc * MACHO_RELINFO64_SIZE;
+ } else {
+ fwriteint32_t(0, machofp);
+ fwriteint32_t(0, machofp);
+ fwriteint32_t(0, machofp);
+ fwriteint32_t(0, machofp);
+ }
+
+ if (s->nreloc) {
+ s->flags |= S_ATTR_LOC_RELOC;
+ if (s->extreloc)
+ s->flags |= S_ATTR_EXT_RELOC;
+ }
+
+ fwriteint32_t(s->flags, machofp); /* flags */
+ fwriteint32_t(0, machofp); /* reserved */
+ fwriteint32_t(0, machofp); /* reserved */
+
+ fwriteint32_t(0, machofp); /* align */
+ }
+
+ rel_padcnt64 = rel_base - offset;
+ offset = rel_base + s_reloff;
+
+ return offset;
+}
+
+/* For a given chain of relocs r, write out the entire relocation
+ chain to the object file. */
+
+static void macho_write_relocs (struct reloc *r)
+{
+ while (r) {
+ uint32_t word2;
+
+ fwriteint32_t(r->addr, machofp); /* reloc offset */
+
+ word2 = r->snum;
+ word2 |= r->pcrel << 24;
+ word2 |= r->length << 25;
+ word2 |= r->ext << 27;
+ word2 |= r->type << 28;
+ fwriteint32_t(word2, machofp); /* reloc data */
+ r = r->next;
+ }
+}
+
+/* Write out the section data. */
+static void macho_write_section (void)
+{
+ struct section *s, *s2;
+ struct reloc *r;
+ uint8_t fi, *p, *q, blk[8];
+ int32_t len;
+ int64_t 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) {
+ len = (int32_t)r->length << 1;
+ if(len > 4) len = 8;
+ saa_fread(s->data, r->addr, blk, len);
+ p = q = blk;
+ l = *p++;
+
+ /* get offset based on relocation type */
+ if (r->length > 0) {
+ l += ((int64_t)*p++) << 8;
+
+ if (r->length > 1) {
+ l += ((int64_t)*p++) << 16;
+ l += ((int64_t)*p++) << 24;
+ }
+
+ if (r->length > 2) {
+ l += ((int64_t)*p++) << 32;
+ l += ((int64_t)*p++) << 40;
+ l += ((int64_t)*p++) << 48;
+ l += ((int64_t)*p++) << 56;
+ }
+
+
+ }
+
+ /* If the relocation is internal add to the current section
+ offset. Otherwise the only value we need is the symbol
+ offset which we already have. The linker takes care
+ of the rest of the address. */
+ if (!r->ext) {
+ /* generate final address by section address and offset */
+ for (s2 = sects, fi = 1;
+ s2 != NULL; s2 = s2->next, fi++) {
+ if (fi == r->snum) {
+ l += s2->addr;
+ break;
+ }
+ }
+ }
+
+ /* write new offset back */
+ if (r->length == 3)
+ WRITEDLONG(q, l);
+ else 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, len);
+ }
+
+ /* dump the section data to file */
+ saa_fpwrite(s->data, machofp);
+ }
+
+ /* pad last section up to reloc entries on int64_t boundary */
+ fwritezero(rel_padcnt64, machofp);
+
+ /* emit relocation entries */
+ for (s = sects; s != NULL; s = s->next)
+ macho_write_relocs (s->relocs);
+}
+
+/* Write out the symbol table. We should already have sorted this
+ before now. */
+static void macho_write_symtab (void)
+{
+ struct symbol *sym;
+ struct section *s;
+ int64_t fi;
+ uint64_t i;
+
+ /* we don't need to pad here since MACHO_RELINFO_SIZE == 8 */
+
+ for (sym = syms; sym != NULL; sym = sym->next) {
+ if ((sym->type & N_EXT) == 0) {
+ fwriteint32_t(sym->strx, machofp); /* string table entry number */
+ fwrite(&sym->type, 1, 1, machofp); /* symbol type */
+ fwrite(&sym->sect, 1, 1, machofp); /* section */
+ fwriteint16_t(sym->desc, machofp); /* description */
+
+ /* Fix up the symbol value now that 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;
+ }
+
+ fwriteint64_t(sym->value, machofp); /* value (i.e. offset) */
+ }
+ }
+
+ for (i = 0; i < nextdefsym; i++) {
+ sym = extdefsyms[i];
+ fwriteint32_t(sym->strx, machofp);
+ fwrite(&sym->type, 1, 1, machofp); /* symbol type */
+ fwrite(&sym->sect, 1, 1, machofp); /* section */
+ fwriteint16_t(sym->desc, machofp); /* description */
+
+ /* Fix up the symbol value now that 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;
+ }
+
+ fwriteint64_t(sym->value, machofp); /* value (i.e. offset) */
+ }
+
+ for (i = 0; i < nundefsym; i++) {
+ sym = undefsyms[i];
+ fwriteint32_t(sym->strx, machofp);
+ fwrite(&sym->type, 1, 1, machofp); /* symbol type */
+ fwrite(&sym->sect, 1, 1, machofp); /* section */
+ fwriteint16_t(sym->desc, machofp); /* description */
+
+ // Fix up the symbol value now that 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;
+ }
+
+ fwriteint64_t(sym->value, machofp); // value (i.e. offset)
+ }
+
+}
+
+/* Fixup the snum in the relocation entries, we should be
+ doing this only for externally referenced symbols. */
+static void macho_fixup_relocs (struct reloc *r)
+{
+ struct symbol *sym;
+
+ while (r != NULL) {
+ if (r->ext) {
+ for (sym = syms; sym != NULL; sym = sym->next) {
+ if (sym->initial_snum == r->snum) {
+ r->snum = sym->snum;
+ break;
+ }
+ }
+ }
+ r = r->next;
+ }
+}
+
+/* Write out the object file. */
+
+static void macho_write (void)
+{
+ uint64_t offset = 0;
+
+ /* mach-o object file structure:
+ **
+ ** mach header
+ ** uint32_t magic
+ ** int cpu type
+ ** int cpu subtype
+ ** uint32_t mach file type
+ ** uint32_t number of load commands
+ ** uint32_t size of all load commands
+ ** (includes section struct size of segment command)
+ ** uint32_t flags
+ **
+ ** segment command
+ ** uint32_t command type == LC_SEGMENT_64
+ ** uint32_t size of load command
+ ** (including section load commands)
+ ** char[16] segment name
+ ** uint64_t in-memory offset
+ ** uint64_t in-memory size
+ ** uint64_t in-file offset to data area
+ ** uint64_t in-file size
+ ** (in-memory size excluding zerofill sections)
+ ** int maximum vm protection
+ ** int initial vm protection
+ ** uint32_t number of sections
+ ** uint32_t flags
+ **
+ ** section commands
+ ** char[16] section name
+ ** char[16] segment name
+ ** uint64_t in-memory offset
+ ** uint64_t in-memory size
+ ** uint32_t in-file offset
+ ** uint32_t alignment
+ ** (irrelevant in MH_OBJECT)
+ ** uint32_t in-file offset of relocation entires
+ ** uint32_t number of relocations
+ ** uint32_t flags
+ ** uint32_t reserved
+ ** uint32_t reserved
+ **
+ ** symbol table command
+ ** uint32_t command type == LC_SYMTAB
+ ** uint32_t size of load command
+ ** uint32_t symbol table offset
+ ** uint32_t number of symbol table entries
+ ** uint32_t string table offset
+ ** uint32_t string table size
+ **
+ ** raw section data
+ **
+ ** padding to int64_t boundary
+ **
+ ** relocation data (struct reloc)
+ ** int32_t offset
+ ** uint data (symbolnum, pcrel, length, extern, type)
+ **
+ ** symbol table data (struct nlist)
+ ** int32_t string table entry number
+ ** uint8_t type
+ ** (extern, absolute, defined in section)
+ ** uint8_t section
+ ** (0 for global symbols, section number of definition (>= 1, <=
+ ** 254) for local symbols, size of variable for common symbols
+ ** [type == extern])
+ ** int16_t description
+ ** (for stab debugging format)
+ ** uint64_t value (i.e. file offset) of symbol or stab offset
+ **
+ ** string table data
+ ** list of null-terminated strings
+ */
+
+ /* Emit the Mach-O header. */
+ macho_write_header();
+
+ offset = MACHO_HEADER64_SIZE + head_sizeofcmds64;
+
+ /* emit the segment load command */
+ if (seg_nsects64 > 0)
+ offset = macho_write_segment (offset);
+ else
+ error(ERR_WARNING, "no sections?");
+
+ if (nsyms > 0) {
+ /* write out symbol command */
+ fwriteint32_t(LC_SYMTAB, machofp); /* cmd == LC_SYMTAB */
+ fwriteint32_t(MACHO_SYMCMD_SIZE, machofp); /* size of load command */
+ fwriteint32_t(offset, machofp); /* symbol table offset */
+ fwriteint32_t(nsyms, machofp); /* number of symbol
+ ** table entries */
+
+ offset += nsyms * MACHO_NLIST64_SIZE;
+ fwriteint32_t(offset, machofp); /* string table offset */
+ fwriteint32_t(strslen, machofp); /* string table size */
+ }
+
+ /* emit section data */
+ if (seg_nsects64 > 0)
+ macho_write_section ();
+
+ /* emit symbol table if we have symbols */
+ if (nsyms > 0)
+ macho_write_symtab ();
+
+ /* we don't need to pad here since MACHO_NLIST64_SIZE == 16 */
+
+ /* emit string table */
+ saa_fpwrite(strs, machofp);
+}
+/* We do quite a bit here, starting with finalizing all of the data
+ for the object file, writing, and then freeing all of the data from
+ the file. */
+
+static void macho_cleanup(int debuginfo)
+{
+ struct section *s;
+ struct reloc *r;
+ struct symbol *sym;
+
+ (void)debuginfo;
+
+ /* Sort all symbols. */
+ macho_layout_symbols (&nsyms, &strslen);
+
+ /* Fixup relocation entries */
+ for (s = sects; s != NULL; s = s->next) {
+ macho_fixup_relocs (s->relocs);
+ }
+
+ /* First calculate and finalize needed values. */
+ macho_calculate_sizes();
+ macho_write();
+
+ /* 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);
+
+ if (syms) {
+ while (syms->next) {
+ sym = syms;
+ syms = syms->next;
+
+ nasm_free (sym);
+ }
+}
+}
+
+/* Debugging routines. */
+static void debug_reloc (struct reloc *r)
+{
+ fprintf (stdout, "reloc:\n");
+ fprintf (stdout, "\taddr: %"PRId32"\n", r->addr);
+ fprintf (stdout, "\tsnum: %d\n", r->snum);
+ fprintf (stdout, "\tpcrel: %d\n", r->pcrel);
+ fprintf (stdout, "\tlength: %d\n", r->length);
+ fprintf (stdout, "\text: %d\n", r->ext);
+ fprintf (stdout, "\ttype: %d\n", r->type);
+}
+
+static void debug_section_relocs (struct section *s)
+{
+ struct reloc *r = s->relocs;
+
+ fprintf (stdout, "relocs for section %s:\n\n", s->sectname);
+
+ while (r != NULL) {
+ debug_reloc (r);
+ r = r->next;
+ }
+}
+
+struct ofmt of_macho64 = {
+ "NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X (x86_64) object files",
+ "macho64",
+ 0,
+ 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 */
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-22 21:09:23 +0000