output/outmacho64.c

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