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