output/outmac64.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2013 The NASM Authors - All Rights Reserved
   4  *   See the file AUTHORS included with the NASM distribution for
   5  *   the specific copyright holders.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following
   9  *   conditions are met:
  10  *
  11  *   * Redistributions of source code must retain the above copyright
  12  *     notice, this list of conditions and the following disclaimer.
  13  *   * Redistributions in binary form must reproduce the above
  14  *     copyright notice, this list of conditions and the following
  15  *     disclaimer in the documentation and/or other materials provided
  16  *     with the distribution.
  17  *
  18  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  19  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  20  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  23  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  26  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * ----------------------------------------------------------------------- */
  33
  34 /*
  35  * outmac64.c   output routines for the Netwide Assembler to produce
  36  *              NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X (x86_64) object files
  37  */
  38
  39 /* Most of this file is, like Mach-O itself, based on a.out. For more
  40  * guidelines see outaout.c.  */
  41
  42 #include "compiler.h"
  43
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <ctype.h>
  48 #include <inttypes.h>
  49
  50 #include "nasm.h"
  51 #include "nasmlib.h"
  52 #include "saa.h"
  53 #include "raa.h"
  54 #include "output/outform.h"
  55 #include "output/outlib.h"
  56
  57 #if defined(OF_MACHO64)
  58
  59 /* Mach-O in-file header structure sizes */
  60 #define MACHO_HEADER64_SIZE             (32)
  61 #define MACHO_SEGCMD64_SIZE             (72)
  62 #define MACHO_SECTCMD64_SIZE    (80)
  63 #define MACHO_SYMCMD_SIZE               (24)
  64 #define MACHO_NLIST64_SIZE              (16)
  65 #define MACHO_RELINFO64_SIZE    (8)
  66
  67 /* Mach-O file header values */
  68 #define MH_MAGIC_64             (0xfeedfacf)
  69 #define CPU_TYPE_X86_64 (0x01000007) /* x86-64 platform */
  70 #define CPU_SUBTYPE_I386_ALL    (3)     /* all-x86 compatible */
  71 #define MH_OBJECT               (0x1)   /* object file */
  72
  73 #define LC_SEGMENT_64   (0x19)  /* segment load command */
  74 #define LC_SYMTAB               (0x2)   /* symbol table load command */
  75
  76 #define VM_PROT_NONE    (0x00)
  77 #define VM_PROT_READ    (0x01)
  78 #define VM_PROT_WRITE   (0x02)
  79 #define VM_PROT_EXECUTE (0x04)
  80
  81 #define VM_PROT_DEFAULT (VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE)
  82 #define VM_PROT_ALL     (VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE)
  83
  84 struct section {
  85     /* nasm internal data */
  86     struct section *next;
  87     struct SAA *data;
  88     int32_t index;
  89     struct reloc *relocs;
  90     int align;
  91
  92     /* data that goes into the file */
  93     char sectname[16];          /* what this section is called */
  94     char segname[16];           /* segment this section will be in */
  95     uint64_t addr;         /* in-memory address (subject to alignment) */
  96     uint64_t size;         /* in-memory and -file size  */
  97     uint32_t nreloc;       /* relocation entry count */
  98     uint32_t flags;        /* type and attributes (masked) */
  99         uint32_t extreloc;     /* external relocations */
 100 };
 101
 102 #define SECTION_TYPE    0x000000ff      /* section type mask */
 103
 104 #define S_REGULAR       (0x0)   /* standard section */
 105 #define S_ZEROFILL      (0x1)   /* zerofill, in-memory only */
 106
 107 #define SECTION_ATTRIBUTES_SYS   0x00ffff00     /* system setable attributes */
 108 #define S_ATTR_SOME_INSTRUCTIONS 0x00000400     /* section contains some
 109                                                    machine instructions */
 110 #define S_ATTR_EXT_RELOC         0x00000200     /* section has external
 111                                                    relocation entries */
 112 #define S_ATTR_LOC_RELOC         0x00000100     /* section has local
 113                                                    relocation entries */
 114 #define S_ATTR_PURE_INSTRUCTIONS 0x80000000             /* section uses pure
 115                                                                                                    machine instructions */
 116
 117 static struct sectmap {
 118     const char *nasmsect;
 119     const char *segname;
 120     const char *sectname;
 121     const int32_t flags;
 122 } sectmap[] = {
 123     {".text", "__TEXT", "__text", S_REGULAR|S_ATTR_SOME_INSTRUCTIONS|S_ATTR_PURE_INSTRUCTIONS},
 124     {".data", "__DATA", "__data", S_REGULAR},
 125     {".rodata", "__DATA", "__const", S_REGULAR},
 126     {".bss", "__DATA", "__bss", S_ZEROFILL},
 127     {NULL, NULL, NULL, 0}
 128 };
 129
 130 struct reloc {
 131     /* nasm internal data */
 132     struct reloc *next;
 133
 134     /* data that goes into the file */
 135     int32_t addr;                  /* op's offset in section */
 136     uint32_t snum:24,       /* contains symbol index if
 137                                 ** ext otherwise in-file
 138                                 ** section number */
 139         pcrel:1,                /* relative relocation */
 140         length:2,               /* 0=byte, 1=word, 2=int32_t, 3=int64_t */
 141         ext:1,                  /* external symbol referenced */
 142         type:4;                 /* reloc type */
 143 };
 144
 145 #define R_ABS           0       /* absolute relocation */
 146 #define R_SCATTERED     0x80000000      /* reloc entry is scattered if
 147                                         ** highest bit == 1 */
 148
 149 struct symbol {
 150     /* nasm internal data */
 151     struct symbol *next;        /* next symbol in the list */
 152     char *name;                 /* name of this symbol */
 153     int32_t initial_snum;               /* symbol number used above in
 154                                    reloc */
 155     int32_t snum;                       /* true snum for reloc */
 156
 157     /* data that goes into the file */
 158     uint32_t strx;                  /* string table index */
 159     uint8_t type;         /* symbol type */
 160     uint8_t sect;         /* NO_SECT or section number */
 161     uint16_t desc;                 /* for stab debugging, 0 for us */
 162     uint64_t value;        /* offset of symbol in section */
 163 };
 164
 165 /* symbol type bits */
 166 #define N_EXT   0x01            /* global or external symbol */
 167
 168 #define N_UNDF  0x0             /* undefined symbol | n_sect == */
 169 #define N_ABS   0x2             /* absolute symbol  |  NO_SECT */
 170 #define N_SECT  0xe             /* defined symbol, n_sect holds
 171                                 ** section number */
 172
 173 #define N_TYPE  0x0e            /* type bit mask */
 174
 175 #define DEFAULT_SECTION_ALIGNMENT 0 /* byte (i.e. no) alignment */
 176
 177 /* special section number values */
 178 #define NO_SECT         0       /* no section, invalid */
 179 #define MAX_SECT        255     /* maximum number of sections */
 180
 181 static struct section *sects, **sectstail;
 182 static struct symbol *syms, **symstail;
 183 static uint32_t nsyms;
 184
 185 /* These variables are set by macho_layout_symbols() to organize
 186    the symbol table and string table in order the dynamic linker
 187    expects.  They are then used in macho_write() to put out the
 188    symbols and strings in that order.
 189
 190    The order of the symbol table is:
 191      local symbols
 192      defined external symbols (sorted by name)
 193      undefined external symbols (sorted by name)
 194
 195    The order of the string table is:
 196      strings for external symbols
 197      strings for local symbols
 198  */
 199 static uint32_t ilocalsym = 0;
 200 static uint32_t iextdefsym = 0;
 201 static uint32_t iundefsym = 0;
 202 static uint32_t nlocalsym;
 203 static uint32_t nextdefsym;
 204 static uint32_t nundefsym;
 205 static struct symbol **extdefsyms = NULL;
 206 static struct symbol **undefsyms = NULL;
 207
 208 static struct RAA *extsyms;
 209 static struct SAA *strs;
 210 static uint32_t strslen;
 211
 212 extern struct ofmt of_macho64;
 213
 214 /* Global file information. This should be cleaned up into either
 215    a structure or as function arguments.  */
 216 uint32_t head_ncmds64 = 0;
 217 uint32_t head_sizeofcmds64 = 0;
 218 uint64_t seg_filesize64 = 0;
 219 uint64_t seg_vmsize64 = 0;
 220 uint32_t seg_nsects64 = 0;
 221 uint64_t rel_padcnt64 = 0;
 222
 223
 224 #define xstrncpy(xdst, xsrc)                                            \
 225     memset(xdst, '\0', sizeof(xdst));   /* zero out whole buffer */     \
 226     strncpy(xdst, xsrc, sizeof(xdst));  /* copy over string */          \
 227     xdst[sizeof(xdst) - 1] = '\0';      /* proper null-termination */
 228
 229 #define alignint32_t(x)                                                 \
 230     ALIGN(x, sizeof(int32_t))      /* align x to int32_t boundary */
 231
 232 #define alignint64_t(x)                                                 \
 233     ALIGN(x, sizeof(int64_t))      /* align x to int64_t boundary */
 234
 235 static void debug_reloc (struct reloc *);
 236 static void debug_section_relocs (struct section *) _unused;
 237
 238 static struct section *get_section_by_name(const char *segname,
 239                                            const char *sectname)
 240 {
 241     struct section *s;
 242
 243     for (s = sects; s != NULL; s = s->next)
 244         if (!strcmp(s->segname, segname) && !strcmp(s->sectname, sectname))
 245             break;
 246
 247     return s;
 248 }
 249
 250 static struct section *get_section_by_index(const int32_t index)
 251 {
 252     struct section *s;
 253
 254     for (s = sects; s != NULL; s = s->next)
 255         if (index == s->index)
 256             break;
 257
 258     return s;
 259 }
 260
 261 static int32_t get_section_index_by_name(const char *segname,
 262                                       const char *sectname)
 263 {
 264     struct section *s;
 265
 266     for (s = sects; s != NULL; s = s->next)
 267         if (!strcmp(s->segname, segname) && !strcmp(s->sectname, sectname))
 268             return s->index;
 269
 270     return -1;
 271 }
 272
 273 static char *get_section_name_by_index(const int32_t index)
 274 {
 275     struct section *s;
 276
 277     for (s = sects; s != NULL; s = s->next)
 278         if (index == s->index)
 279             return s->sectname;
 280
 281     return NULL;
 282 }
 283
 284 static uint8_t get_section_fileindex_by_index(const int32_t index)
 285 {
 286     struct section *s;
 287     uint8_t i = 1;
 288
 289     for (s = sects; s != NULL && i < MAX_SECT; s = s->next, ++i)
 290         if (index == s->index)
 291             return i;
 292
 293     if (i == MAX_SECT)
 294         nasm_error(ERR_WARNING,
 295               "too many sections (>255) - clipped by fileindex");
 296
 297     return NO_SECT;
 298 }
 299
 300 static struct symbol *get_closest_section_symbol_by_offset(uint8_t fileindex, int64_t offset)
 301 {
 302     struct symbol *nearest = NULL;
 303     struct symbol *sym;
 304
 305     for (sym = syms; sym; sym = sym->next) {
 306         if ((sym->sect != NO_SECT) && (sym->sect == fileindex)) {
 307             if ((int64_t)sym->value > offset)
 308                 break;
 309             nearest = sym;
 310         }
 311     }
 312
 313     if (!nearest)
 314         nasm_error(ERR_FATAL, "No section for index %x offset %llx found\n",
 315                    fileindex, (long long)offset);
 316
 317     return nearest;
 318 }
 319
 320 /*
 321  * Special section numbers which are used to define Mach-O special
 322  * symbols, which can be used with WRT to provide PIC relocation
 323  * types.
 324  */
 325 static int32_t macho_gotpcrel_sect;
 326
 327 static void macho_init(void)
 328 {
 329     char zero = 0;
 330
 331     maxbits = 64;
 332
 333     sects = NULL;
 334     sectstail = &sects;
 335
 336     syms = NULL;
 337     symstail = &syms;
 338     nsyms = 0;
 339     nlocalsym = 0;
 340     nextdefsym = 0;
 341     nundefsym = 0;
 342
 343     extsyms = raa_init();
 344     strs = saa_init(1L);
 345
 346     /* string table starts with a zero byte - don't ask why */
 347     saa_wbytes(strs, &zero, sizeof(char));
 348     strslen = 1;
 349
 350     /* add special symbol for ..gotpcrel */
 351     macho_gotpcrel_sect = seg_alloc();
 352     macho_gotpcrel_sect++;
 353     define_label("..gotpcrel", macho_gotpcrel_sect, 0L, NULL, false, false);
 354 }
 355
 356 static void sect_write(struct section *sect,
 357                        const uint8_t *data, uint32_t len)
 358 {
 359     saa_wbytes(sect->data, data, len);
 360     sect->size += len;
 361 }
 362
 363 static int32_t add_reloc(struct section *sect, int32_t section,
 364                       int pcrel, int bytes, int64_t reloff)
 365 {
 366     struct reloc *r;
 367     struct symbol *sym;
 368     int32_t fi;
 369     int32_t adjustment = 0;
 370
 371     /* NeXT as puts relocs in reversed order (address-wise) into the
 372      ** files, so we do the same, doesn't seem to make much of a
 373      ** difference either way */
 374     r = nasm_malloc(sizeof(struct reloc));
 375     r->next = sect->relocs;
 376     sect->relocs = r;
 377
 378     /* the current end of the section will be the symbol's address for
 379      ** now, might have to be fixed by macho_fixup_relocs() later on. make
 380      ** sure we don't make the symbol scattered by setting the highest
 381      ** bit by accident */
 382     r->addr = sect->size & ~R_SCATTERED;
 383     r->ext = 1;
 384     r->pcrel = (pcrel ? 1 : 0);
 385
 386     /* match byte count 1, 2, 4, 8 to length codes 0, 1, 2, 3 respectively */
 387         switch(bytes){
 388                 case 1:
 389                         r->length = 0;
 390                         break;
 391                 case 2:
 392                         r->length = 1;
 393                         break;
 394                 case 4:
 395                         r->length = 2;
 396                         break;
 397                 case 8:
 398                         r->length = 3;
 399                         break;
 400                 default:
 401                         break;
 402         }
 403
 404     /* set default relocation values */
 405     r->type = 0;                                        // X86_64_RELOC_UNSIGNED
 406         r->snum = R_ABS;                                // Absolute Symbol (indicates no relocation)
 407
 408         /* absolute relocation */
 409         if (pcrel == 0) {
 410
 411                 /* intra-section */
 412                 if (section == NO_SEG) {
 413                         // r->snum = R_ABS;             // Set above
 414
 415                 /* inter-section */
 416                 } else {
 417                         fi = get_section_fileindex_by_index(section);
 418
 419                         /* external */
 420                         if (fi == NO_SECT) {
 421                                 r->snum = raa_read(extsyms, section);
 422
 423                         /* local */
 424                         } else {
 425                                 sym = get_closest_section_symbol_by_offset(fi, reloff);
 426                                 r->snum = sym->initial_snum;
 427                                 adjustment = sym->value;
 428                         }
 429                 }
 430
 431         /* relative relocation */
 432         } else if (pcrel == 1) {
 433
 434                 /* intra-section */
 435                 if (section == NO_SEG) {
 436                         r->type = 1;                    // X86_64_RELOC_SIGNED
 437
 438                 /* inter-section */
 439                 } else {
 440                         r->type = 2;                    // X86_64_RELOC_BRANCH
 441                         fi = get_section_fileindex_by_index(section);
 442
 443                         /* external */
 444                         if (fi == NO_SECT) {
 445                                 sect->extreloc = 1;
 446                                 r->snum = raa_read(extsyms, section);
 447
 448                         /* local */
 449                         } else {
 450                                 sym = get_closest_section_symbol_by_offset(fi, reloff);
 451                                 r->snum = sym->initial_snum;
 452                                 adjustment = sym->value;
 453                         }
 454                 }
 455
 456         /* subtractor */
 457         } else if (pcrel == 2) {
 458                 r->pcrel = 0;
 459                 r->type = 5;                            // X86_64_RELOC_SUBTRACTOR
 460
 461         /* gotpcrel */
 462         } else if (pcrel == 3) {
 463                 r->type = 4;                            // X86_64_RELOC_GOT
 464                 r->snum = macho_gotpcrel_sect;
 465
 466         /* gotpcrel MOVQ load */
 467         } else if (pcrel == 4) {
 468                 r->type = 3;                            // X86_64_RELOC_GOT_LOAD
 469                 r->snum = macho_gotpcrel_sect;
 470         }
 471
 472         ++sect->nreloc;
 473
 474         return adjustment;
 475 }
 476
 477 static void macho_output(int32_t secto, const void *data,
 478                          enum out_type type, uint64_t size,
 479                          int32_t section, int32_t wrt)
 480 {
 481     struct section *s, *sbss;
 482     int64_t addr;
 483     uint8_t mydata[16], *p, gotload;
 484
 485     if (secto == NO_SEG) {
 486         if (type != OUT_RESERVE)
 487             nasm_error(ERR_NONFATAL, "attempt to assemble code in "
 488                   "[ABSOLUTE] space");
 489
 490         return;
 491     }
 492
 493     s = get_section_by_index(secto);
 494
 495     if (s == NULL) {
 496         nasm_error(ERR_WARNING, "attempt to assemble code in"
 497               " section %d: defaulting to `.text'", secto);
 498         s = get_section_by_name("__TEXT", "__text");
 499
 500         /* should never happen */
 501         if (s == NULL)
 502             nasm_error(ERR_PANIC, "text section not found");
 503     }
 504
 505     sbss = get_section_by_name("__DATA", "__bss");
 506
 507     if (s == sbss && type != OUT_RESERVE) {
 508         nasm_error(ERR_WARNING, "attempt to initialize memory in the"
 509               " BSS section: ignored");
 510         s->size += realsize(type, size);
 511         return;
 512     }
 513
 514     memset(mydata, 0, sizeof(mydata));
 515
 516     switch (type) {
 517     case OUT_RESERVE:
 518         if (s != sbss) {
 519             nasm_error(ERR_WARNING, "uninitialized space declared in"
 520                   " %s section: zeroing",
 521                   get_section_name_by_index(secto));
 522
 523             sect_write(s, NULL, size);
 524         } else
 525             s->size += size;
 526
 527         break;
 528
 529     case OUT_RAWDATA:
 530         if (section != NO_SEG)
 531             nasm_error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
 532
 533         sect_write(s, data, size);
 534         break;
 535
 536     case OUT_ADDRESS:
 537     {
 538         int asize = abs(size);
 539
 540         addr = *(int64_t *)data;
 541         if (section != NO_SEG) {
 542             if (section % 2) {
 543                 nasm_error(ERR_NONFATAL, "Mach-O format does not support"
 544                       " section base references");
 545             } else {
 546                                 if (wrt == NO_SEG) {
 547                                         if (asize < 8) {
 548                                                 nasm_error(ERR_NONFATAL, "Mach-O 64-bit format does not support"
 549                                                         " 32-bit absolute addresses");
 550                                         /*
 551                                          Seemingly, Mach-O's X86_64_RELOC_SUBTRACTOR would require
 552                                          pre-determined knowledge of where the image base would be,
 553                                          making it impractical for use in intermediate object files
 554                                          */
 555                                         } else {
 556                                                 addr -= add_reloc(s, section, 0, asize, addr);                                  // X86_64_RELOC_UNSIGNED
 557                                         }
 558                                 } else {
 559                                         nasm_error(ERR_NONFATAL, "Mach-O format does not support"
 560                                                 " this use of WRT");
 561                                 }
 562                         }
 563                 }
 564
 565         p = mydata;
 566         WRITEADDR(p, addr, asize);
 567         sect_write(s, mydata, asize);
 568         break;
 569     }
 570
 571     case OUT_REL2ADR:
 572         p = mydata;
 573         WRITESHORT(p, *(int64_t *)data);
 574
 575         if (section == secto)
 576             nasm_error(ERR_PANIC, "intra-section OUT_REL2ADR");
 577
 578                 if (section == NO_SEG) {
 579                         /* Do nothing */
 580         } else if (section % 2) {
 581             nasm_error(ERR_NONFATAL, "Mach-O format does not support"
 582                   " section base references");
 583         } else {
 584                         nasm_error(ERR_NONFATAL, "Unsupported non-32-bit"
 585                                   " Macho-O relocation [2]");
 586                 }
 587
 588         sect_write(s, mydata, 2L);
 589         break;
 590
 591     case OUT_REL4ADR:
 592         p = mydata;
 593         WRITELONG(p, *(int64_t *)data + 4 - size);
 594
 595         if (section == secto)
 596             nasm_error(ERR_PANIC, "intra-section OUT_REL4ADR");
 597
 598         if (section != NO_SEG && section % 2) {
 599             nasm_error(ERR_NONFATAL, "Mach-O format does not support"
 600                   " section base references");
 601         } else {
 602                         if (wrt == NO_SEG) {
 603                                 *(int64_t *)mydata -= add_reloc(s, section, 1, 4, *(int64_t *)mydata);                          // X86_64_RELOC_SIGNED/BRANCH
 604                         } else if (wrt == macho_gotpcrel_sect) {
 605                                 if (s->data->datalen > 1) {
 606                                         saa_fread(s->data, s->data->datalen-2, &gotload, 1);                            // Retrieve Instruction Opcode
 607                                 } else {
 608                                         gotload = 0;
 609                                 }
 610                                 if (gotload == 0x8B) {                                                                                                  // Check for MOVQ Opcode
 611                                         *(int64_t *)mydata -= add_reloc(s, section, 4, 4, *(int64_t *)mydata);                  // X86_64_GOT_LOAD (MOVQ load)
 612                                 } else {
 613                                         *(int64_t *)mydata -= add_reloc(s, section, 3, 4, *(int64_t *)mydata);                  // X86_64_GOT
 614                                 }
 615                         } else {
 616                                 nasm_error(ERR_NONFATAL, "Mach-O format does not support"
 617                                     " this use of WRT");
 618                                 wrt = NO_SEG;   /* we can at least _try_ to continue */
 619                         }
 620                 }
 621
 622         sect_write(s, mydata, 4L);
 623         break;
 624
 625     default:
 626         nasm_error(ERR_PANIC, "unknown output type?");
 627         break;
 628     }
 629 }
 630
 631 static int32_t macho_section(char *name, int pass, int *bits)
 632 {
 633     int32_t index, originalIndex;
 634     char *sectionAttributes;
 635     struct sectmap *sm;
 636     struct section *s;
 637
 638     (void)pass;
 639
 640     /* Default to 64 bits. */
 641     if (!name) {
 642         *bits = 64;
 643         name = ".text";
 644         sectionAttributes = NULL;
 645     } else {
 646         sectionAttributes = name;
 647         name = nasm_strsep(&sectionAttributes, " \t");
 648     }
 649
 650     for (sm = sectmap; sm->nasmsect != NULL; ++sm) {
 651         /* make lookup into section name translation table */
 652         if (!strcmp(name, sm->nasmsect)) {
 653             char *currentAttribute;
 654
 655             /* try to find section with that name */
 656             originalIndex = index = get_section_index_by_name(sm->segname,
 657                                                               sm->sectname);
 658
 659             /* create it if it doesn't exist yet */
 660             if (index == -1) {
 661                 s = *sectstail = nasm_malloc(sizeof(struct section));
 662                 s->next = NULL;
 663                 sectstail = &s->next;
 664
 665                 s->data = saa_init(1L);
 666                 s->index = seg_alloc();
 667                 s->relocs = NULL;
 668                 s->align = -1;
 669
 670                 xstrncpy(s->segname, sm->segname);
 671                 xstrncpy(s->sectname, sm->sectname);
 672                 s->size = 0;
 673                 s->nreloc = 0;
 674                 s->flags = sm->flags;
 675
 676                 index = s->index;
 677             } else {
 678                 s = get_section_by_index(index);
 679             }
 680
 681             while ((NULL != sectionAttributes)
 682                    && (currentAttribute = nasm_strsep(&sectionAttributes, " \t"))) {
 683                 if (0 != *currentAttribute) {
 684                     if (!nasm_strnicmp("align=", currentAttribute, 6)) {
 685                         char *end;
 686                         int newAlignment, value;
 687
 688                         value = strtoul(currentAttribute + 6, (char**)&end, 0);
 689                         newAlignment = alignlog2_32(value);
 690
 691                         if (0 != *end) {
 692                             nasm_error(ERR_PANIC,
 693                                   "unknown or missing alignment value \"%s\" "
 694                                       "specified for section \"%s\"",
 695                                   currentAttribute + 6,
 696                                   name);
 697                             return NO_SEG;
 698                         } else if (0 > newAlignment) {
 699                             nasm_error(ERR_PANIC,
 700                                   "alignment of %d (for section \"%s\") is not "
 701                                       "a power of two",
 702                                   value,
 703                                   name);
 704                             return NO_SEG;
 705                         }
 706
 707                         if ((-1 != originalIndex)
 708                             && (s->align != newAlignment)
 709                            && (s->align != -1)) {
 710                             nasm_error(ERR_PANIC,
 711                                   "section \"%s\" has already been specified "
 712                                       "with alignment %d, conflicts with new "
 713                                       "alignment of %d",
 714                             name,
 715                             (1 << s->align),
 716                             value);
 717                             return NO_SEG;
 718                         }
 719
 720                         s->align = newAlignment;
 721                     } else if (!nasm_stricmp("data", currentAttribute)) {
 722                         /* Do nothing; 'data' is implicit */
 723                     } else {
 724                         nasm_error(ERR_PANIC,
 725                               "unknown section attribute %s for section %s",
 726                               currentAttribute,
 727                               name);
 728                         return NO_SEG;
 729                     }
 730                 }
 731             }
 732
 733             return index;
 734         }
 735     }
 736
 737     nasm_error(ERR_PANIC, "invalid section name %s", name);
 738     return NO_SEG;
 739 }
 740
 741 static void macho_symdef(char *name, int32_t section, int64_t offset,
 742                          int is_global, char *special)
 743 {
 744     struct symbol *sym;
 745
 746     if (special) {
 747         nasm_error(ERR_NONFATAL, "The Mach-O output format does "
 748               "not support any special symbol types");
 749         return;
 750     }
 751
 752     if (is_global == 3) {
 753         nasm_error(ERR_NONFATAL, "The Mach-O format does not "
 754               "(yet) support forward reference fixups.");
 755         return;
 756     }
 757
 758         if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
 759         /*
 760          * This is a NASM special symbol. We never allow it into
 761          * the Macho-O symbol table, even if it's a valid one. If it
 762          * _isn't_ a valid one, we should barf immediately.
 763          */
 764         if (strcmp(name, "..gotpcrel"))
 765             nasm_error(ERR_NONFATAL, "unrecognized special symbol `%s'", name);
 766          return;
 767     }
 768
 769     sym = *symstail = nasm_malloc(sizeof(struct symbol));
 770     sym->next = NULL;
 771     symstail = &sym->next;
 772
 773     sym->name = name;
 774     sym->strx = strslen;
 775     sym->type = 0;
 776     sym->desc = 0;
 777     sym->value = offset;
 778     sym->initial_snum = -1;
 779
 780     /* external and common symbols get N_EXT */
 781     if (is_global != 0) {
 782         sym->type |= N_EXT;
 783         }
 784
 785     if (section == NO_SEG) {
 786         /* symbols in no section get absolute */
 787         sym->type |= N_ABS;
 788         sym->sect = NO_SECT;
 789     } else {
 790         sym->type |= N_SECT;
 791
 792         /* get the in-file index of the section the symbol was defined in */
 793         sym->sect = get_section_fileindex_by_index(section);
 794
 795                 /* track the initially allocated symbol number for use in future fix-ups */
 796                 sym->initial_snum = nsyms;
 797
 798         if (sym->sect == NO_SECT) {
 799
 800             /* remember symbol number of references to external
 801              ** symbols, this works because every external symbol gets
 802              ** its own section number allocated internally by nasm and
 803              ** can so be used as a key */
 804                         extsyms = raa_write(extsyms, section, nsyms);
 805
 806             switch (is_global) {
 807             case 1:
 808             case 2:
 809                 /* there isn't actually a difference between global
 810                  ** and common symbols, both even have their size in
 811                  ** sym->value */
 812                 sym->type = N_EXT;
 813                 break;
 814
 815             default:
 816                 /* give an error on unfound section if it's not an
 817                  ** external or common symbol (assemble_file() does a
 818                  ** seg_alloc() on every call for them) */
 819                 nasm_error(ERR_PANIC, "in-file index for section %d not found",
 820                       section);
 821             }
 822         }
 823     }
 824     ++nsyms;
 825 }
 826
 827 static void macho_sectalign(int32_t seg, unsigned int value)
 828 {
 829     struct section *s;
 830
 831     list_for_each(s, sects) {
 832         if (s->index == seg)
 833             break;
 834     }
 835
 836     if (!s || !is_power2(value))
 837         return;
 838
 839     value = alignlog2_32(value);
 840     if (s->align < (int)value)
 841         s->align = value;
 842 }
 843
 844 static int32_t macho_segbase(int32_t section)
 845 {
 846     return section;
 847 }
 848
 849 static void macho_filename(char *inname, char *outname)
 850 {
 851     standard_extension(inname, outname, ".o");
 852 }
 853
 854 extern macros_t macho_stdmac[];
 855
 856 /* Comparison function for qsort symbol layout.  */
 857 static int layout_compare (const struct symbol **s1,
 858                            const struct symbol **s2)
 859 {
 860     return (strcmp ((*s1)->name, (*s2)->name));
 861 }
 862
 863 /* The native assembler does a few things in a similar function
 864
 865         * Remove temporary labels
 866         * Sort symbols according to local, external, undefined (by name)
 867         * Order the string table
 868
 869    We do not remove temporary labels right now.
 870
 871    numsyms is the total number of symbols we have. strtabsize is the
 872    number entries in the string table.  */
 873
 874 static void macho_layout_symbols (uint32_t *numsyms,
 875                                   uint32_t *strtabsize)
 876 {
 877     struct symbol *sym, **symp;
 878     uint32_t i,j;
 879
 880     *numsyms = 0;
 881     *strtabsize = sizeof (char);
 882
 883     symp = &syms;
 884
 885     while ((sym = *symp)) {
 886         /* Undefined symbols are now external.  */
 887         if (sym->type == N_UNDF)
 888             sym->type |= N_EXT;
 889
 890         if ((sym->type & N_EXT) == 0) {
 891             sym->snum = *numsyms;
 892             *numsyms = *numsyms + 1;
 893             nlocalsym++;
 894         }
 895         else {
 896                 if ((sym->type & N_TYPE) != N_UNDF) {
 897                         nextdefsym++;
 898             } else {
 899                         nundefsym++;
 900                 }
 901
 902             /* If we handle debug info we'll want
 903                to check for it here instead of just
 904                adding the symbol to the string table.  */
 905             sym->strx = *strtabsize;
 906             saa_wbytes (strs, sym->name, (int32_t)(strlen(sym->name) + 1));
 907             *strtabsize += strlen(sym->name) + 1;
 908         }
 909         symp = &(sym->next);
 910     }
 911
 912     /* Next, sort the symbols.  Most of this code is a direct translation from
 913        the Apple cctools symbol layout. We need to keep compatibility with that.  */
 914     /* Set the indexes for symbol groups into the symbol table */
 915     ilocalsym = 0;
 916     iextdefsym = nlocalsym;
 917     iundefsym = nlocalsym + nextdefsym;
 918
 919     /* allocate arrays for sorting externals by name */
 920     extdefsyms = nasm_malloc(nextdefsym * sizeof(struct symbol *));
 921     undefsyms = nasm_malloc(nundefsym * sizeof(struct symbol *));
 922
 923     i = 0;
 924     j = 0;
 925
 926     symp = &syms;
 927
 928     while ((sym = *symp)) {
 929
 930         if((sym->type & N_EXT) == 0) {
 931             sym->strx = *strtabsize;
 932             saa_wbytes (strs, sym->name, (int32_t)(strlen (sym->name) + 1));
 933             *strtabsize += strlen(sym->name) + 1;
 934         }
 935         else {
 936                 if((sym->type & N_TYPE) != N_UNDF) {
 937                         extdefsyms[i++] = sym;
 938             } else {
 939                         undefsyms[j++] = sym;
 940                 }
 941         }
 942         symp = &(sym->next);
 943     }
 944
 945     qsort(extdefsyms, nextdefsym, sizeof(struct symbol *),
 946           (int (*)(const void *, const void *))layout_compare);
 947     qsort(undefsyms, nundefsym, sizeof(struct symbol *),
 948           (int (*)(const void *, const void *))layout_compare);
 949
 950     for(i = 0; i < nextdefsym; i++) {
 951         extdefsyms[i]->snum = *numsyms;
 952         *numsyms += 1;
 953     }
 954     for(j = 0; j < nundefsym; j++) {
 955         undefsyms[j]->snum = *numsyms;
 956         *numsyms += 1;
 957     }
 958 }
 959
 960 /* Calculate some values we'll need for writing later.  */
 961
 962 static void macho_calculate_sizes (void)
 963 {
 964     struct section *s;
 965
 966     /* count sections and calculate in-memory and in-file offsets */
 967     for (s = sects; s != NULL; s = s->next) {
 968         uint64_t pad = 0;
 969
 970         /* zerofill sections aren't actually written to the file */
 971         if ((s->flags & SECTION_TYPE) != S_ZEROFILL)
 972             seg_filesize64 += s->size;
 973
 974         /* recalculate segment address based on alignment and vm size */
 975         s->addr = seg_vmsize64;
 976         /* we need section alignment to calculate final section address */
 977         if (s->align == -1)
 978             s->align = DEFAULT_SECTION_ALIGNMENT;
 979         if(s->align) {
 980             uint64_t newaddr = ALIGN(s->addr, 1 << s->align);
 981             pad = newaddr - s->addr;
 982             s->addr = newaddr;
 983         }
 984
 985         seg_vmsize64 += s->size + pad;
 986         ++seg_nsects64;
 987     }
 988
 989     /* calculate size of all headers, load commands and sections to
 990     ** get a pointer to the start of all the raw data */
 991     if (seg_nsects64 > 0) {
 992         ++head_ncmds64;
 993         head_sizeofcmds64 +=
 994             MACHO_SEGCMD64_SIZE + seg_nsects64 * MACHO_SECTCMD64_SIZE;
 995     }
 996
 997     if (nsyms > 0) {
 998         ++head_ncmds64;
 999         head_sizeofcmds64 += MACHO_SYMCMD_SIZE;
1000     }
1001 }
1002
1003 /* Write out the header information for the file.  */
1004
1005 static void macho_write_header (void)
1006 {
1007     fwriteint32_t(MH_MAGIC_64, ofile);  /* magic */
1008     fwriteint32_t(CPU_TYPE_X86_64, ofile);      /* CPU type */
1009     fwriteint32_t(CPU_SUBTYPE_I386_ALL, ofile); /* CPU subtype */
1010     fwriteint32_t(MH_OBJECT, ofile);    /* Mach-O file type */
1011     fwriteint32_t(head_ncmds64, ofile); /* number of load commands */
1012     fwriteint32_t(head_sizeofcmds64, ofile);    /* size of load commands */
1013     fwriteint32_t(0, ofile);    /* no flags */
1014     fwriteint32_t(0, ofile);    /* reserved for future use */
1015 }
1016
1017 /* Write out the segment load command at offset.  */
1018
1019 static uint32_t macho_write_segment (uint64_t offset)
1020 {
1021     uint64_t rel_base = alignint64_t (offset + seg_filesize64);
1022     uint32_t s_reloff = 0;
1023     struct section *s;
1024
1025     fwriteint32_t(LC_SEGMENT_64, ofile);        /* cmd == LC_SEGMENT_64 */
1026
1027     /* size of load command including section load commands */
1028     fwriteint32_t(MACHO_SEGCMD64_SIZE + seg_nsects64 *
1029                MACHO_SECTCMD64_SIZE, ofile);
1030
1031     /* in an MH_OBJECT file all sections are in one unnamed (name
1032     ** all zeros) segment */
1033     fwritezero(16, ofile);
1034     fwriteint64_t(0, ofile); /* in-memory offset */
1035     fwriteint64_t(seg_vmsize64, ofile);        /* in-memory size */
1036     fwriteint64_t(offset, ofile);    /* in-file offset to data */
1037     fwriteint64_t(seg_filesize64, ofile);      /* in-file size */
1038     fwriteint32_t(VM_PROT_DEFAULT, ofile);   /* maximum vm protection */
1039     fwriteint32_t(VM_PROT_DEFAULT, ofile);   /* initial vm protection */
1040     fwriteint32_t(seg_nsects64, ofile);        /* number of sections */
1041     fwriteint32_t(0, ofile); /* no flags */
1042
1043     /* emit section headers */
1044     for (s = sects; s != NULL; s = s->next) {
1045         nasm_write(s->sectname, sizeof(s->sectname), ofile);
1046         nasm_write(s->segname, sizeof(s->segname), ofile);
1047         fwriteint64_t(s->addr, ofile);
1048         fwriteint64_t(s->size, ofile);
1049
1050         /* dummy data for zerofill sections or proper values */
1051         if ((s->flags & SECTION_TYPE) != S_ZEROFILL) {
1052             fwriteint32_t(offset, ofile);
1053             /* Write out section alignment, as a power of two.
1054             e.g. 32-bit word alignment would be 2 (2^2 = 4).  */
1055             if (s->align == -1)
1056                 s->align = DEFAULT_SECTION_ALIGNMENT;
1057             fwriteint32_t(s->align, ofile);
1058             /* To be compatible with cctools as we emit
1059             a zero reloff if we have no relocations.  */
1060             fwriteint32_t(s->nreloc ? rel_base + s_reloff : 0, ofile);
1061             fwriteint32_t(s->nreloc, ofile);
1062
1063             offset += s->size;
1064             s_reloff += s->nreloc * MACHO_RELINFO64_SIZE;
1065         } else {
1066             fwriteint32_t(0, ofile);
1067             fwriteint32_t(0, ofile);
1068             fwriteint32_t(0, ofile);
1069             fwriteint32_t(0, ofile);
1070         }
1071
1072                 if (s->nreloc) {
1073                         s->flags |= S_ATTR_LOC_RELOC;
1074                         if (s->extreloc)
1075                                 s->flags |= S_ATTR_EXT_RELOC;
1076                 }
1077
1078         fwriteint32_t(s->flags, ofile);      /* flags */
1079         fwriteint32_t(0, ofile);     /* reserved */
1080         fwriteint32_t(0, ofile);     /* reserved */
1081
1082                 fwriteint32_t(0, ofile);     /* align */
1083     }
1084
1085     rel_padcnt64 = rel_base - offset;
1086     offset = rel_base + s_reloff;
1087
1088     return offset;
1089 }
1090
1091 /* For a given chain of relocs r, write out the entire relocation
1092    chain to the object file.  */
1093
1094 static void macho_write_relocs (struct reloc *r)
1095 {
1096     while (r) {
1097         uint32_t word2;
1098
1099         fwriteint32_t(r->addr, ofile); /* reloc offset */
1100
1101         word2 = r->snum;
1102         word2 |= r->pcrel << 24;
1103         word2 |= r->length << 25;
1104         word2 |= r->ext << 27;
1105         word2 |= r->type << 28;
1106         fwriteint32_t(word2, ofile); /* reloc data */
1107         r = r->next;
1108     }
1109 }
1110
1111 /* Write out the section data.  */
1112 static void macho_write_section (void)
1113 {
1114     struct section *s, *s2;
1115     struct reloc *r;
1116     uint8_t fi, *p, *q, blk[8];
1117         int32_t len;
1118     int64_t l;
1119
1120     for (s = sects; s != NULL; s = s->next) {
1121         if ((s->flags & SECTION_TYPE) == S_ZEROFILL)
1122             continue;
1123
1124         /* no padding needs to be done to the sections */
1125
1126         /* Like a.out Mach-O references things in the data or bss
1127          * sections by addresses which are actually relative to the
1128          * start of the _text_ section, in the _file_. See outaout.c
1129          * for more information. */
1130         saa_rewind(s->data);
1131         for (r = s->relocs; r != NULL; r = r->next) {
1132                 len = (int32_t)r->length << 1;
1133                 if(len > 4) len = 8;
1134             saa_fread(s->data, r->addr, blk, len);
1135             p = q = blk;
1136             l = *p++;
1137
1138             /* get offset based on relocation type */
1139             if (r->length > 0) {
1140                         l += ((int64_t)*p++) << 8;
1141
1142                         if (r->length > 1) {
1143                                 l += ((int64_t)*p++) << 16;
1144                                 l += ((int64_t)*p++) << 24;
1145                         }
1146
1147                         if (r->length > 2) {
1148                                 l += ((int64_t)*p++) << 32;
1149                                 l += ((int64_t)*p++) << 40;
1150                                 l += ((int64_t)*p++) << 48;
1151                                 l += ((int64_t)*p++) << 56;
1152                         }
1153
1154
1155             }
1156
1157             /* If the relocation is internal add to the current section
1158                offset. Otherwise the only value we need is the symbol
1159                offset which we already have. The linker takes care
1160                of the rest of the address.  */
1161             if (!r->ext) {
1162             /* generate final address by section address and offset */
1163                     for (s2 = sects, fi = 1;
1164                         s2 != NULL; s2 = s2->next, fi++) {
1165                         if (fi == r->snum) {
1166                             l += s2->addr;
1167                             break;
1168                         }
1169                     }
1170             }
1171
1172             /* write new offset back */
1173                 if (r->length == 3)
1174                 WRITEDLONG(q, l);
1175                 else if (r->length == 2)
1176                 WRITELONG(q, l);
1177             else if (r->length == 1)
1178                 WRITESHORT(q, l);
1179             else
1180                 *q++ = l & 0xFF;
1181
1182             saa_fwrite(s->data, r->addr, blk, len);
1183         }
1184
1185         /* dump the section data to file */
1186         saa_fpwrite(s->data, ofile);
1187     }
1188
1189     /* pad last section up to reloc entries on int64_t boundary */
1190     fwritezero(rel_padcnt64, ofile);
1191
1192     /* emit relocation entries */
1193     for (s = sects; s != NULL; s = s->next)
1194         macho_write_relocs (s->relocs);
1195 }
1196
1197 /* Write out the symbol table. We should already have sorted this
1198    before now.  */
1199 static void macho_write_symtab (void)
1200 {
1201     struct symbol *sym;
1202     struct section *s;
1203     int64_t fi;
1204     uint64_t i;
1205
1206     /* we don't need to pad here since MACHO_RELINFO_SIZE == 8 */
1207
1208     for (sym = syms; sym != NULL; sym = sym->next) {
1209         if ((sym->type & N_EXT) == 0) {
1210             fwriteint32_t(sym->strx, ofile);            /* string table entry number */
1211             nasm_write(&sym->type, 1, ofile);           /* symbol type */
1212             nasm_write(&sym->sect, 1, ofile);           /* section */
1213             fwriteint16_t(sym->desc, ofile);            /* description */
1214
1215             /* Fix up the symbol value now that we know the final section
1216                sizes.  */
1217             if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
1218                     for (s = sects, fi = 1; s != NULL; s = s->next, fi++) {
1219                         if (fi == sym->sect) {
1220                             sym->value += s->addr;
1221                             break;
1222                         }
1223                     }
1224             }
1225
1226             fwriteint64_t(sym->value, ofile);   /* value (i.e. offset) */
1227         }
1228     }
1229
1230     for (i = 0; i < nextdefsym; i++) {
1231         sym = extdefsyms[i];
1232         fwriteint32_t(sym->strx, ofile);
1233         nasm_write(&sym->type, 1, ofile);       /* symbol type */
1234         nasm_write(&sym->sect, 1, ofile);       /* section */
1235         fwriteint16_t(sym->desc, ofile);        /* description */
1236
1237         /* Fix up the symbol value now that we know the final section
1238            sizes.  */
1239         if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
1240             for (s = sects, fi = 1;
1241                  s != NULL && fi < sym->sect; s = s->next, ++fi)
1242                 sym->value += s->size;
1243         }
1244
1245         fwriteint64_t(sym->value, ofile);       /* value (i.e. offset) */
1246     }
1247
1248      for (i = 0; i < nundefsym; i++) {
1249          sym = undefsyms[i];
1250          fwriteint32_t(sym->strx, ofile);
1251          nasm_write(&sym->type, 1, ofile);      /* symbol type */
1252          nasm_write(&sym->sect, 1, ofile);      /* section */
1253          fwriteint16_t(sym->desc, ofile);       /* description */
1254
1255          // Fix up the symbol value now that we know the final section sizes.
1256          if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
1257              for (s = sects, fi = 1;
1258                   s != NULL && fi < sym->sect; s = s->next, ++fi)
1259                  sym->value += s->size;
1260          }
1261
1262          fwriteint64_t(sym->value, ofile);      // value (i.e. offset)
1263      }
1264
1265 }
1266
1267 /* Fixup the snum in the relocation entries, we should be
1268    doing this only for externally referenced symbols. */
1269 static void macho_fixup_relocs (struct reloc *r)
1270 {
1271     struct symbol *sym;
1272
1273     while (r != NULL) {
1274         if (r->ext) {
1275         for (sym = syms; sym != NULL; sym = sym->next) {
1276                 if (sym->initial_snum == r->snum) {
1277                         r->snum = sym->snum;
1278                         break;
1279                 }
1280         }
1281         }
1282         r = r->next;
1283     }
1284 }
1285
1286 /* Write out the object file.  */
1287
1288 static void macho_write (void)
1289 {
1290     uint64_t offset = 0;
1291
1292     /* mach-o object file structure:
1293     **
1294     ** mach header
1295     **  uint32_t magic
1296     **  int   cpu type
1297     **  int   cpu subtype
1298     **  uint32_t mach file type
1299     **  uint32_t number of load commands
1300     **  uint32_t size of all load commands
1301     **   (includes section struct size of segment command)
1302     **  uint32_t flags
1303     **
1304     ** segment command
1305     **  uint32_t command type == LC_SEGMENT_64
1306     **  uint32_t size of load command
1307     **   (including section load commands)
1308     **  char[16] segment name
1309     **  uint64_t in-memory offset
1310     **  uint64_t in-memory size
1311     **  uint64_t in-file offset to data area
1312     **  uint64_t in-file size
1313     **   (in-memory size excluding zerofill sections)
1314     **  int   maximum vm protection
1315     **  int   initial vm protection
1316     **  uint32_t number of sections
1317     **  uint32_t flags
1318     **
1319     ** section commands
1320     **   char[16] section name
1321     **   char[16] segment name
1322     **   uint64_t in-memory offset
1323     **   uint64_t in-memory size
1324     **   uint32_t in-file offset
1325     **   uint32_t alignment
1326     **    (irrelevant in MH_OBJECT)
1327     **   uint32_t in-file offset of relocation entires
1328     **   uint32_t number of relocations
1329     **   uint32_t flags
1330     **   uint32_t reserved
1331     **   uint32_t reserved
1332     **
1333     ** symbol table command
1334     **  uint32_t command type == LC_SYMTAB
1335     **  uint32_t size of load command
1336     **  uint32_t symbol table offset
1337     **  uint32_t number of symbol table entries
1338     **  uint32_t string table offset
1339     **  uint32_t string table size
1340     **
1341     ** raw section data
1342     **
1343     ** padding to int64_t boundary
1344     **
1345     ** relocation data (struct reloc)
1346     ** int32_t offset
1347     **  uint data (symbolnum, pcrel, length, extern, type)
1348     **
1349     ** symbol table data (struct nlist)
1350     **  int32_t  string table entry number
1351     **  uint8_t type
1352     **   (extern, absolute, defined in section)
1353     **  uint8_t section
1354     **   (0 for global symbols, section number of definition (>= 1, <=
1355     **   254) for local symbols, size of variable for common symbols
1356     **   [type == extern])
1357     **  int16_t description
1358     **   (for stab debugging format)
1359     **  uint64_t value (i.e. file offset) of symbol or stab offset
1360     **
1361     ** string table data
1362     **  list of null-terminated strings
1363     */
1364
1365     /* Emit the Mach-O header.  */
1366     macho_write_header();
1367
1368     offset = MACHO_HEADER64_SIZE + head_sizeofcmds64;
1369
1370     /* emit the segment load command */
1371     if (seg_nsects64 > 0)
1372         offset = macho_write_segment (offset);
1373     else
1374         nasm_error(ERR_WARNING, "no sections?");
1375
1376     if (nsyms > 0) {
1377         /* write out symbol command */
1378         fwriteint32_t(LC_SYMTAB, ofile); /* cmd == LC_SYMTAB */
1379         fwriteint32_t(MACHO_SYMCMD_SIZE, ofile); /* size of load command */
1380         fwriteint32_t(offset, ofile);    /* symbol table offset */
1381         fwriteint32_t(nsyms, ofile);     /* number of symbol
1382                                          ** table entries */
1383
1384         offset += nsyms * MACHO_NLIST64_SIZE;
1385         fwriteint32_t(offset, ofile);    /* string table offset */
1386         fwriteint32_t(strslen, ofile);   /* string table size */
1387     }
1388
1389     /* emit section data */
1390     if (seg_nsects64 > 0)
1391         macho_write_section ();
1392
1393     /* emit symbol table if we have symbols */
1394     if (nsyms > 0)
1395         macho_write_symtab ();
1396
1397     /* we don't need to pad here since MACHO_NLIST64_SIZE == 16 */
1398
1399     /* emit string table */
1400     saa_fpwrite(strs, ofile);
1401 }
1402 /* We do quite a bit here, starting with finalizing all of the data
1403    for the object file, writing, and then freeing all of the data from
1404    the file.  */
1405
1406 static void macho_cleanup(int debuginfo)
1407 {
1408     struct section *s;
1409     struct reloc *r;
1410     struct symbol *sym;
1411
1412     (void)debuginfo;
1413
1414     /* Sort all symbols.  */
1415     macho_layout_symbols (&nsyms, &strslen);
1416
1417     /* Fixup relocation entries */
1418     for (s = sects; s != NULL; s = s->next) {
1419         macho_fixup_relocs (s->relocs);
1420     }
1421
1422     /* First calculate and finalize needed values.  */
1423     macho_calculate_sizes();
1424     macho_write();
1425
1426     /* free up everything */
1427     while (sects->next) {
1428         s = sects;
1429         sects = sects->next;
1430
1431         saa_free(s->data);
1432         while (s->relocs != NULL) {
1433             r = s->relocs;
1434             s->relocs = s->relocs->next;
1435             nasm_free(r);
1436         }
1437
1438         nasm_free(s);
1439     }
1440
1441     saa_free(strs);
1442     raa_free(extsyms);
1443
1444     if (syms) {
1445     while (syms->next) {
1446        sym = syms;
1447        syms = syms->next;
1448
1449        nasm_free (sym);
1450     }
1451 }
1452 }
1453
1454 /* Debugging routines.  */
1455 static void debug_reloc (struct reloc *r)
1456 {
1457     fprintf (stdout, "reloc:\n");
1458     fprintf (stdout, "\taddr: %"PRId32"\n", r->addr);
1459     fprintf (stdout, "\tsnum: %d\n", r->snum);
1460     fprintf (stdout, "\tpcrel: %d\n", r->pcrel);
1461     fprintf (stdout, "\tlength: %d\n", r->length);
1462     fprintf (stdout, "\text: %d\n", r->ext);
1463     fprintf (stdout, "\ttype: %d\n", r->type);
1464 }
1465
1466 static void debug_section_relocs (struct section *s)
1467 {
1468     struct reloc *r = s->relocs;
1469
1470     fprintf (stdout, "relocs for section %s:\n\n", s->sectname);
1471
1472     while (r != NULL) {
1473         debug_reloc (r);
1474         r = r->next;
1475     }
1476 }
1477
1478 struct ofmt of_macho64 = {
1479     "NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X (x86_64) object files",
1480     "macho64",
1481     0,
1482     null_debug_arr,
1483     &null_debug_form,
1484     macho_stdmac,
1485     macho_init,
1486     null_setinfo,
1487     macho_output,
1488     macho_symdef,
1489     macho_section,
1490     macho_sectalign,
1491     macho_segbase,
1492     null_directive,
1493     macho_filename,
1494     macho_cleanup
1495 };
1496
1497 #endif
1498
1499 /*
1500  * Local Variables:
1501  * mode:c
1502  * c-basic-offset:4
1503  * End:
1504  *
1505  * end of file */