doc: Update changes
[nasm/avx512.git] / output / outmac64.c
blob6dc0c44a1ac0158ec8f8fbeea0b6449abc09c3ed
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.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
9 * conditions are met:
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.
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.
32 * ----------------------------------------------------------------------- */
35 * outmac64.c output routines for the Netwide Assembler to produce
36 * NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X (x86_64) object files
39 /* Most of this file is, like Mach-O itself, based on a.out. For more
40 * guidelines see outaout.c. */
42 #include "compiler.h"
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <string.h>
47 #include <ctype.h>
48 #include <inttypes.h>
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"
57 #if defined(OF_MACHO64)
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)
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 */
73 #define LC_SEGMENT_64 (0x19) /* segment load command */
74 #define LC_SYMTAB (0x2) /* symbol table load command */
76 #define VM_PROT_NONE (0x00)
77 #define VM_PROT_READ (0x01)
78 #define VM_PROT_WRITE (0x02)
79 #define VM_PROT_EXECUTE (0x04)
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)
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;
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 */
102 #define SECTION_TYPE 0x000000ff /* section type mask */
104 #define S_REGULAR (0x0) /* standard section */
105 #define S_ZEROFILL (0x1) /* zerofill, in-memory only */
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 */
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}
130 struct reloc {
131 /* nasm internal data */
132 struct reloc *next;
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 */
145 #define R_ABS 0 /* absolute relocation */
146 #define R_SCATTERED 0x80000000 /* reloc entry is scattered if
147 ** highest bit == 1 */
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 */
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 */
165 /* symbol type bits */
166 #define N_EXT 0x01 /* global or external symbol */
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 */
173 #define N_TYPE 0x0e /* type bit mask */
175 #define DEFAULT_SECTION_ALIGNMENT 0 /* byte (i.e. no) alignment */
177 /* special section number values */
178 #define NO_SECT 0 /* no section, invalid */
179 #define MAX_SECT 255 /* maximum number of sections */
181 static struct section *sects, **sectstail;
182 static struct symbol *syms, **symstail;
183 static uint32_t nsyms;
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.
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)
195 The order of the string table is:
196 strings for external symbols
197 strings for local symbols
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;
208 static struct RAA *extsyms;
209 static struct SAA *strs;
210 static uint32_t strslen;
212 extern struct ofmt of_macho64;
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;
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 */
229 #define alignint32_t(x) \
230 ALIGN(x, sizeof(int32_t)) /* align x to int32_t boundary */
232 #define alignint64_t(x) \
233 ALIGN(x, sizeof(int64_t)) /* align x to int64_t boundary */
235 static void debug_reloc (struct reloc *);
236 static void debug_section_relocs (struct section *) _unused;
238 static struct section *get_section_by_name(const char *segname,
239 const char *sectname)
241 struct section *s;
243 for (s = sects; s != NULL; s = s->next)
244 if (!strcmp(s->segname, segname) && !strcmp(s->sectname, sectname))
245 break;
247 return s;
250 static struct section *get_section_by_index(const int32_t index)
252 struct section *s;
254 for (s = sects; s != NULL; s = s->next)
255 if (index == s->index)
256 break;
258 return s;
261 static int32_t get_section_index_by_name(const char *segname,
262 const char *sectname)
264 struct section *s;
266 for (s = sects; s != NULL; s = s->next)
267 if (!strcmp(s->segname, segname) && !strcmp(s->sectname, sectname))
268 return s->index;
270 return -1;
273 static char *get_section_name_by_index(const int32_t index)
275 struct section *s;
277 for (s = sects; s != NULL; s = s->next)
278 if (index == s->index)
279 return s->sectname;
281 return NULL;
284 static uint8_t get_section_fileindex_by_index(const int32_t index)
286 struct section *s;
287 uint8_t i = 1;
289 for (s = sects; s != NULL && i < MAX_SECT; s = s->next, ++i)
290 if (index == s->index)
291 return i;
293 if (i == MAX_SECT)
294 nasm_error(ERR_WARNING,
295 "too many sections (>255) - clipped by fileindex");
297 return NO_SECT;
300 static struct symbol *get_closest_section_symbol_by_offset(uint8_t fileindex, int64_t offset)
302 struct symbol *sym;
303 struct symbol *nearest = NULL;
304 int64_t sval, nval, sdiff, ndiff;
306 for (sym = syms; sym != NULL; sym = sym->next) {
307 if ((sym->sect != NO_SECT) && (sym->sect == fileindex)){
308 if(nearest == NULL){
309 nearest = sym;
310 }else{
311 sval = (int64_t)sym->value;
312 nval = (int64_t)nearest->value;
314 sdiff = ((sval >= offset) ? (sval - offset) : (offset - sval));
315 ndiff = ((nval >= offset) ? (nval - offset) : (offset - nval));
317 if(sdiff <= ndiff){
318 nearest = sym;
321 /* Symbols should be in order, so this optimization should be OK */
322 if((int64_t)nearest->value >= offset){
323 break;
329 return nearest;
334 * Special section numbers which are used to define Mach-O special
335 * symbols, which can be used with WRT to provide PIC relocation
336 * types.
338 static int32_t macho_gotpcrel_sect;
340 static void macho_init(void)
342 char zero = 0;
344 maxbits = 64;
346 sects = NULL;
347 sectstail = &sects;
349 syms = NULL;
350 symstail = &syms;
351 nsyms = 0;
352 nlocalsym = 0;
353 nextdefsym = 0;
354 nundefsym = 0;
356 extsyms = raa_init();
357 strs = saa_init(1L);
359 /* string table starts with a zero byte - don't ask why */
360 saa_wbytes(strs, &zero, sizeof(char));
361 strslen = 1;
363 /* add special symbol for ..gotpcrel */
364 macho_gotpcrel_sect = seg_alloc();
365 macho_gotpcrel_sect++;
366 define_label("..gotpcrel", macho_gotpcrel_sect, 0L, NULL, false, false);
369 static void sect_write(struct section *sect,
370 const uint8_t *data, uint32_t len)
372 saa_wbytes(sect->data, data, len);
373 sect->size += len;
376 static int32_t add_reloc(struct section *sect, int32_t section,
377 int pcrel, int bytes, int64_t reloff)
379 struct reloc *r;
380 struct symbol *sym;
381 int32_t fi;
382 int32_t adjustment = 0;
384 /* NeXT as puts relocs in reversed order (address-wise) into the
385 ** files, so we do the same, doesn't seem to make much of a
386 ** difference either way */
387 r = nasm_malloc(sizeof(struct reloc));
388 r->next = sect->relocs;
389 sect->relocs = r;
391 /* the current end of the section will be the symbol's address for
392 ** now, might have to be fixed by macho_fixup_relocs() later on. make
393 ** sure we don't make the symbol scattered by setting the highest
394 ** bit by accident */
395 r->addr = sect->size & ~R_SCATTERED;
396 r->ext = 1;
397 r->pcrel = (pcrel ? 1 : 0);
399 /* match byte count 1, 2, 4, 8 to length codes 0, 1, 2, 3 respectively */
400 switch(bytes){
401 case 1:
402 r->length = 0;
403 break;
404 case 2:
405 r->length = 1;
406 break;
407 case 4:
408 r->length = 2;
409 break;
410 case 8:
411 r->length = 3;
412 break;
413 default:
414 break;
417 /* set default relocation values */
418 r->type = 0; // X86_64_RELOC_UNSIGNED
419 r->snum = R_ABS; // Absolute Symbol (indicates no relocation)
421 /* absolute relocation */
422 if (pcrel == 0) {
424 /* intra-section */
425 if (section == NO_SEG) {
426 // r->snum = R_ABS; // Set above
428 /* inter-section */
429 } else {
430 fi = get_section_fileindex_by_index(section);
432 /* external */
433 if (fi == NO_SECT) {
434 r->snum = raa_read(extsyms, section);
436 /* local */
437 } else {
438 sym = get_closest_section_symbol_by_offset(fi, reloff);
439 r->snum = sym->initial_snum;
440 adjustment = sym->value;
444 /* relative relocation */
445 } else if (pcrel == 1) {
447 /* intra-section */
448 if (section == NO_SEG) {
449 r->type = 1; // X86_64_RELOC_SIGNED
451 /* inter-section */
452 } else {
453 r->type = 2; // X86_64_RELOC_BRANCH
454 fi = get_section_fileindex_by_index(section);
456 /* external */
457 if (fi == NO_SECT) {
458 sect->extreloc = 1;
459 r->snum = raa_read(extsyms, section);
461 /* local */
462 } else {
463 sym = get_closest_section_symbol_by_offset(fi, reloff);
464 r->snum = sym->initial_snum;
465 adjustment = sym->value;
469 /* subtractor */
470 } else if (pcrel == 2) {
471 r->pcrel = 0;
472 r->type = 5; // X86_64_RELOC_SUBTRACTOR
474 /* gotpcrel */
475 } else if (pcrel == 3) {
476 r->type = 4; // X86_64_RELOC_GOT
477 r->snum = macho_gotpcrel_sect;
479 /* gotpcrel MOVQ load */
480 } else if (pcrel == 4) {
481 r->type = 3; // X86_64_RELOC_GOT_LOAD
482 r->snum = macho_gotpcrel_sect;
485 ++sect->nreloc;
487 return adjustment;
490 static void macho_output(int32_t secto, const void *data,
491 enum out_type type, uint64_t size,
492 int32_t section, int32_t wrt)
494 struct section *s, *sbss;
495 int64_t addr;
496 uint8_t mydata[16], *p, gotload;
498 if (secto == NO_SEG) {
499 if (type != OUT_RESERVE)
500 nasm_error(ERR_NONFATAL, "attempt to assemble code in "
501 "[ABSOLUTE] space");
503 return;
506 s = get_section_by_index(secto);
508 if (s == NULL) {
509 nasm_error(ERR_WARNING, "attempt to assemble code in"
510 " section %d: defaulting to `.text'", secto);
511 s = get_section_by_name("__TEXT", "__text");
513 /* should never happen */
514 if (s == NULL)
515 nasm_error(ERR_PANIC, "text section not found");
518 sbss = get_section_by_name("__DATA", "__bss");
520 if (s == sbss && type != OUT_RESERVE) {
521 nasm_error(ERR_WARNING, "attempt to initialize memory in the"
522 " BSS section: ignored");
523 s->size += realsize(type, size);
524 return;
527 switch (type) {
528 case OUT_RESERVE:
529 if (s != sbss) {
530 nasm_error(ERR_WARNING, "uninitialized space declared in"
531 " %s section: zeroing",
532 get_section_name_by_index(secto));
534 sect_write(s, NULL, size);
535 } else
536 s->size += size;
538 break;
540 case OUT_RAWDATA:
541 if (section != NO_SEG)
542 nasm_error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
544 sect_write(s, data, size);
545 break;
547 case OUT_ADDRESS:
548 addr = *(int64_t *)data;
549 if (section != NO_SEG) {
550 if (section % 2) {
551 nasm_error(ERR_NONFATAL, "Mach-O format does not support"
552 " section base references");
553 } else {
554 if (wrt == NO_SEG) {
555 if (size < 8) {
556 nasm_error(ERR_NONFATAL, "Mach-O 64-bit format does not support"
557 " 32-bit absolute addresses");
559 Seemingly, Mach-O's X86_64_RELOC_SUBTRACTOR would require
560 pre-determined knowledge of where the image base would be,
561 making it impractical for use in intermediate object files
563 } else {
564 addr -= add_reloc(s, section, 0, size, addr); // X86_64_RELOC_UNSIGNED
566 } else {
567 nasm_error(ERR_NONFATAL, "Mach-O format does not support"
568 " this use of WRT");
573 p = mydata;
574 WRITEADDR(p, addr, size);
575 sect_write(s, mydata, size);
576 break;
578 case OUT_REL2ADR:
579 p = mydata;
580 WRITESHORT(p, *(int64_t *)data);
582 if (section == secto)
583 nasm_error(ERR_PANIC, "intra-section OUT_REL2ADR");
585 if (section == NO_SEG) {
586 /* Do nothing */
587 } else if (section % 2) {
588 nasm_error(ERR_NONFATAL, "Mach-O format does not support"
589 " section base references");
590 } else {
591 nasm_error(ERR_NONFATAL, "Unsupported non-32-bit"
592 " Macho-O relocation [2]");
595 sect_write(s, mydata, 2L);
596 break;
598 case OUT_REL4ADR:
599 p = mydata;
600 WRITELONG(p, *(int64_t *)data);
602 if (section == secto)
603 nasm_error(ERR_PANIC, "intra-section OUT_REL4ADR");
605 if (section != NO_SEG && section % 2) {
606 nasm_error(ERR_NONFATAL, "Mach-O format does not support"
607 " section base references");
608 } else {
609 if (wrt == NO_SEG) {
610 *mydata -= add_reloc(s, section, 1, 4, (int64_t)*mydata); // X86_64_RELOC_SIGNED/BRANCH
611 } else if (wrt == macho_gotpcrel_sect) {
612 if (s->data->datalen > 1) {
613 saa_fread(s->data, s->data->datalen-2, &gotload, 1); // Retrieve Instruction Opcode
614 } else {
615 gotload = 0;
617 if (gotload == 0x8B) { // Check for MOVQ Opcode
618 *mydata -= add_reloc(s, section, 4, 4, (int64_t)*mydata); // X86_64_GOT_LOAD (MOVQ load)
619 } else {
620 *mydata -= add_reloc(s, section, 3, 4, (int64_t)*mydata); // X86_64_GOT
622 } else {
623 nasm_error(ERR_NONFATAL, "Mach-O format does not support"
624 " this use of WRT");
625 wrt = NO_SEG; /* we can at least _try_ to continue */
629 sect_write(s, mydata, 4L);
630 break;
632 default:
633 nasm_error(ERR_PANIC, "unknown output type?");
634 break;
638 static int32_t macho_section(char *name, int pass, int *bits)
640 int32_t index, originalIndex;
641 char *sectionAttributes;
642 struct sectmap *sm;
643 struct section *s;
645 (void)pass;
647 /* Default to 64 bits. */
648 if (!name) {
649 *bits = 64;
650 name = ".text";
651 sectionAttributes = NULL;
652 } else {
653 sectionAttributes = name;
654 name = nasm_strsep(&sectionAttributes, " \t");
657 for (sm = sectmap; sm->nasmsect != NULL; ++sm) {
658 /* make lookup into section name translation table */
659 if (!strcmp(name, sm->nasmsect)) {
660 char *currentAttribute;
662 /* try to find section with that name */
663 originalIndex = index = get_section_index_by_name(sm->segname,
664 sm->sectname);
666 /* create it if it doesn't exist yet */
667 if (index == -1) {
668 s = *sectstail = nasm_malloc(sizeof(struct section));
669 s->next = NULL;
670 sectstail = &s->next;
672 s->data = saa_init(1L);
673 s->index = seg_alloc();
674 s->relocs = NULL;
675 s->align = -1;
677 xstrncpy(s->segname, sm->segname);
678 xstrncpy(s->sectname, sm->sectname);
679 s->size = 0;
680 s->nreloc = 0;
681 s->flags = sm->flags;
683 index = s->index;
684 } else {
685 s = get_section_by_index(index);
688 while ((NULL != sectionAttributes)
689 && (currentAttribute = nasm_strsep(&sectionAttributes, " \t"))) {
690 if (0 != *currentAttribute) {
691 if (!nasm_strnicmp("align=", currentAttribute, 6)) {
692 char *end;
693 int newAlignment, value;
695 value = strtoul(currentAttribute + 6, (char**)&end, 0);
696 newAlignment = alignlog2_32(value);
698 if (0 != *end) {
699 nasm_error(ERR_PANIC,
700 "unknown or missing alignment value \"%s\" "
701 "specified for section \"%s\"",
702 currentAttribute + 6,
703 name);
704 return NO_SEG;
705 } else if (0 > newAlignment) {
706 nasm_error(ERR_PANIC,
707 "alignment of %d (for section \"%s\") is not "
708 "a power of two",
709 value,
710 name);
711 return NO_SEG;
714 if ((-1 != originalIndex)
715 && (s->align != newAlignment)
716 && (s->align != -1)) {
717 nasm_error(ERR_PANIC,
718 "section \"%s\" has already been specified "
719 "with alignment %d, conflicts with new "
720 "alignment of %d",
721 name,
722 (1 << s->align),
723 value);
724 return NO_SEG;
727 s->align = newAlignment;
728 } else if (!nasm_stricmp("data", currentAttribute)) {
729 /* Do nothing; 'data' is implicit */
730 } else {
731 nasm_error(ERR_PANIC,
732 "unknown section attribute %s for section %s",
733 currentAttribute,
734 name);
735 return NO_SEG;
740 return index;
744 nasm_error(ERR_PANIC, "invalid section name %s", name);
745 return NO_SEG;
748 static void macho_symdef(char *name, int32_t section, int64_t offset,
749 int is_global, char *special)
751 struct symbol *sym;
753 if (special) {
754 nasm_error(ERR_NONFATAL, "The Mach-O output format does "
755 "not support any special symbol types");
756 return;
759 if (is_global == 3) {
760 nasm_error(ERR_NONFATAL, "The Mach-O format does not "
761 "(yet) support forward reference fixups.");
762 return;
765 if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
767 * This is a NASM special symbol. We never allow it into
768 * the Macho-O symbol table, even if it's a valid one. If it
769 * _isn't_ a valid one, we should barf immediately.
771 if (strcmp(name, "..gotpcrel"))
772 nasm_error(ERR_NONFATAL, "unrecognized special symbol `%s'", name);
773 return;
776 sym = *symstail = nasm_malloc(sizeof(struct symbol));
777 sym->next = NULL;
778 symstail = &sym->next;
780 sym->name = name;
781 sym->strx = strslen;
782 sym->type = 0;
783 sym->desc = 0;
784 sym->value = offset;
785 sym->initial_snum = -1;
787 /* external and common symbols get N_EXT */
788 if (is_global != 0) {
789 sym->type |= N_EXT;
792 if (section == NO_SEG) {
793 /* symbols in no section get absolute */
794 sym->type |= N_ABS;
795 sym->sect = NO_SECT;
796 } else {
797 sym->type |= N_SECT;
799 /* get the in-file index of the section the symbol was defined in */
800 sym->sect = get_section_fileindex_by_index(section);
802 /* track the initially allocated symbol number for use in future fix-ups */
803 sym->initial_snum = nsyms;
805 if (sym->sect == NO_SECT) {
807 /* remember symbol number of references to external
808 ** symbols, this works because every external symbol gets
809 ** its own section number allocated internally by nasm and
810 ** can so be used as a key */
811 extsyms = raa_write(extsyms, section, nsyms);
813 switch (is_global) {
814 case 1:
815 case 2:
816 /* there isn't actually a difference between global
817 ** and common symbols, both even have their size in
818 ** sym->value */
819 sym->type = N_EXT;
820 break;
822 default:
823 /* give an error on unfound section if it's not an
824 ** external or common symbol (assemble_file() does a
825 ** seg_alloc() on every call for them) */
826 nasm_error(ERR_PANIC, "in-file index for section %d not found",
827 section);
831 ++nsyms;
834 static void macho_sectalign(int32_t seg, unsigned int value)
836 struct section *s;
838 list_for_each(s, sects) {
839 if (s->index == seg)
840 break;
843 if (!s || !is_power2(value))
844 return;
846 value = alignlog2_32(value);
847 if (s->align < (int)value)
848 s->align = value;
851 static int32_t macho_segbase(int32_t section)
853 return section;
856 static void macho_filename(char *inname, char *outname)
858 standard_extension(inname, outname, ".o");
861 extern macros_t macho_stdmac[];
863 /* Comparison function for qsort symbol layout. */
864 static int layout_compare (const struct symbol **s1,
865 const struct symbol **s2)
867 return (strcmp ((*s1)->name, (*s2)->name));
870 /* The native assembler does a few things in a similar function
872 * Remove temporary labels
873 * Sort symbols according to local, external, undefined (by name)
874 * Order the string table
876 We do not remove temporary labels right now.
878 numsyms is the total number of symbols we have. strtabsize is the
879 number entries in the string table. */
881 static void macho_layout_symbols (uint32_t *numsyms,
882 uint32_t *strtabsize)
884 struct symbol *sym, **symp;
885 uint32_t i,j;
887 *numsyms = 0;
888 *strtabsize = sizeof (char);
890 symp = &syms;
892 while ((sym = *symp)) {
893 /* Undefined symbols are now external. */
894 if (sym->type == N_UNDF)
895 sym->type |= N_EXT;
897 if ((sym->type & N_EXT) == 0) {
898 sym->snum = *numsyms;
899 *numsyms = *numsyms + 1;
900 nlocalsym++;
902 else {
903 if ((sym->type & N_TYPE) != N_UNDF) {
904 nextdefsym++;
905 } else {
906 nundefsym++;
909 /* If we handle debug info we'll want
910 to check for it here instead of just
911 adding the symbol to the string table. */
912 sym->strx = *strtabsize;
913 saa_wbytes (strs, sym->name, (int32_t)(strlen(sym->name) + 1));
914 *strtabsize += strlen(sym->name) + 1;
916 symp = &(sym->next);
919 /* Next, sort the symbols. Most of this code is a direct translation from
920 the Apple cctools symbol layout. We need to keep compatibility with that. */
921 /* Set the indexes for symbol groups into the symbol table */
922 ilocalsym = 0;
923 iextdefsym = nlocalsym;
924 iundefsym = nlocalsym + nextdefsym;
926 /* allocate arrays for sorting externals by name */
927 extdefsyms = nasm_malloc(nextdefsym * sizeof(struct symbol *));
928 undefsyms = nasm_malloc(nundefsym * sizeof(struct symbol *));
930 i = 0;
931 j = 0;
933 symp = &syms;
935 while ((sym = *symp)) {
937 if((sym->type & N_EXT) == 0) {
938 sym->strx = *strtabsize;
939 saa_wbytes (strs, sym->name, (int32_t)(strlen (sym->name) + 1));
940 *strtabsize += strlen(sym->name) + 1;
942 else {
943 if((sym->type & N_TYPE) != N_UNDF) {
944 extdefsyms[i++] = sym;
945 } else {
946 undefsyms[j++] = sym;
949 symp = &(sym->next);
952 qsort(extdefsyms, nextdefsym, sizeof(struct symbol *),
953 (int (*)(const void *, const void *))layout_compare);
954 qsort(undefsyms, nundefsym, sizeof(struct symbol *),
955 (int (*)(const void *, const void *))layout_compare);
957 for(i = 0; i < nextdefsym; i++) {
958 extdefsyms[i]->snum = *numsyms;
959 *numsyms += 1;
961 for(j = 0; j < nundefsym; j++) {
962 undefsyms[j]->snum = *numsyms;
963 *numsyms += 1;
967 /* Calculate some values we'll need for writing later. */
969 static void macho_calculate_sizes (void)
971 struct section *s;
973 /* count sections and calculate in-memory and in-file offsets */
974 for (s = sects; s != NULL; s = s->next) {
975 uint64_t pad = 0;
977 /* zerofill sections aren't actually written to the file */
978 if ((s->flags & SECTION_TYPE) != S_ZEROFILL)
979 seg_filesize64 += s->size;
981 /* recalculate segment address based on alignment and vm size */
982 s->addr = seg_vmsize64;
983 /* we need section alignment to calculate final section address */
984 if (s->align == -1)
985 s->align = DEFAULT_SECTION_ALIGNMENT;
986 if(s->align) {
987 uint64_t newaddr = ALIGN(s->addr, 1 << s->align);
988 pad = newaddr - s->addr;
989 s->addr = newaddr;
992 seg_vmsize64 += s->size + pad;
993 ++seg_nsects64;
996 /* calculate size of all headers, load commands and sections to
997 ** get a pointer to the start of all the raw data */
998 if (seg_nsects64 > 0) {
999 ++head_ncmds64;
1000 head_sizeofcmds64 +=
1001 MACHO_SEGCMD64_SIZE + seg_nsects64 * MACHO_SECTCMD64_SIZE;
1004 if (nsyms > 0) {
1005 ++head_ncmds64;
1006 head_sizeofcmds64 += MACHO_SYMCMD_SIZE;
1010 /* Write out the header information for the file. */
1012 static void macho_write_header (void)
1014 fwriteint32_t(MH_MAGIC_64, ofile); /* magic */
1015 fwriteint32_t(CPU_TYPE_X86_64, ofile); /* CPU type */
1016 fwriteint32_t(CPU_SUBTYPE_I386_ALL, ofile); /* CPU subtype */
1017 fwriteint32_t(MH_OBJECT, ofile); /* Mach-O file type */
1018 fwriteint32_t(head_ncmds64, ofile); /* number of load commands */
1019 fwriteint32_t(head_sizeofcmds64, ofile); /* size of load commands */
1020 fwriteint32_t(0, ofile); /* no flags */
1021 fwriteint32_t(0, ofile); /* reserved for future use */
1024 /* Write out the segment load command at offset. */
1026 static uint32_t macho_write_segment (uint64_t offset)
1028 uint64_t rel_base = alignint64_t (offset + seg_filesize64);
1029 uint32_t s_reloff = 0;
1030 struct section *s;
1032 fwriteint32_t(LC_SEGMENT_64, ofile); /* cmd == LC_SEGMENT_64 */
1034 /* size of load command including section load commands */
1035 fwriteint32_t(MACHO_SEGCMD64_SIZE + seg_nsects64 *
1036 MACHO_SECTCMD64_SIZE, ofile);
1038 /* in an MH_OBJECT file all sections are in one unnamed (name
1039 ** all zeros) segment */
1040 fwritezero(16, ofile);
1041 fwriteint64_t(0, ofile); /* in-memory offset */
1042 fwriteint64_t(seg_vmsize64, ofile); /* in-memory size */
1043 fwriteint64_t(offset, ofile); /* in-file offset to data */
1044 fwriteint64_t(seg_filesize64, ofile); /* in-file size */
1045 fwriteint32_t(VM_PROT_DEFAULT, ofile); /* maximum vm protection */
1046 fwriteint32_t(VM_PROT_DEFAULT, ofile); /* initial vm protection */
1047 fwriteint32_t(seg_nsects64, ofile); /* number of sections */
1048 fwriteint32_t(0, ofile); /* no flags */
1050 /* emit section headers */
1051 for (s = sects; s != NULL; s = s->next) {
1052 fwrite(s->sectname, sizeof(s->sectname), 1, ofile);
1053 fwrite(s->segname, sizeof(s->segname), 1, ofile);
1054 fwriteint64_t(s->addr, ofile);
1055 fwriteint64_t(s->size, ofile);
1057 /* dummy data for zerofill sections or proper values */
1058 if ((s->flags & SECTION_TYPE) != S_ZEROFILL) {
1059 fwriteint32_t(offset, ofile);
1060 /* Write out section alignment, as a power of two.
1061 e.g. 32-bit word alignment would be 2 (2^2 = 4). */
1062 if (s->align == -1)
1063 s->align = DEFAULT_SECTION_ALIGNMENT;
1064 fwriteint32_t(s->align, ofile);
1065 /* To be compatible with cctools as we emit
1066 a zero reloff if we have no relocations. */
1067 fwriteint32_t(s->nreloc ? rel_base + s_reloff : 0, ofile);
1068 fwriteint32_t(s->nreloc, ofile);
1070 offset += s->size;
1071 s_reloff += s->nreloc * MACHO_RELINFO64_SIZE;
1072 } else {
1073 fwriteint32_t(0, ofile);
1074 fwriteint32_t(0, ofile);
1075 fwriteint32_t(0, ofile);
1076 fwriteint32_t(0, ofile);
1079 if (s->nreloc) {
1080 s->flags |= S_ATTR_LOC_RELOC;
1081 if (s->extreloc)
1082 s->flags |= S_ATTR_EXT_RELOC;
1085 fwriteint32_t(s->flags, ofile); /* flags */
1086 fwriteint32_t(0, ofile); /* reserved */
1087 fwriteint32_t(0, ofile); /* reserved */
1089 fwriteint32_t(0, ofile); /* align */
1092 rel_padcnt64 = rel_base - offset;
1093 offset = rel_base + s_reloff;
1095 return offset;
1098 /* For a given chain of relocs r, write out the entire relocation
1099 chain to the object file. */
1101 static void macho_write_relocs (struct reloc *r)
1103 while (r) {
1104 uint32_t word2;
1106 fwriteint32_t(r->addr, ofile); /* reloc offset */
1108 word2 = r->snum;
1109 word2 |= r->pcrel << 24;
1110 word2 |= r->length << 25;
1111 word2 |= r->ext << 27;
1112 word2 |= r->type << 28;
1113 fwriteint32_t(word2, ofile); /* reloc data */
1114 r = r->next;
1118 /* Write out the section data. */
1119 static void macho_write_section (void)
1121 struct section *s, *s2;
1122 struct reloc *r;
1123 uint8_t fi, *p, *q, blk[8];
1124 int32_t len;
1125 int64_t l;
1127 for (s = sects; s != NULL; s = s->next) {
1128 if ((s->flags & SECTION_TYPE) == S_ZEROFILL)
1129 continue;
1131 /* no padding needs to be done to the sections */
1133 /* Like a.out Mach-O references things in the data or bss
1134 * sections by addresses which are actually relative to the
1135 * start of the _text_ section, in the _file_. See outaout.c
1136 * for more information. */
1137 saa_rewind(s->data);
1138 for (r = s->relocs; r != NULL; r = r->next) {
1139 len = (int32_t)r->length << 1;
1140 if(len > 4) len = 8;
1141 saa_fread(s->data, r->addr, blk, len);
1142 p = q = blk;
1143 l = *p++;
1145 /* get offset based on relocation type */
1146 if (r->length > 0) {
1147 l += ((int64_t)*p++) << 8;
1149 if (r->length > 1) {
1150 l += ((int64_t)*p++) << 16;
1151 l += ((int64_t)*p++) << 24;
1154 if (r->length > 2) {
1155 l += ((int64_t)*p++) << 32;
1156 l += ((int64_t)*p++) << 40;
1157 l += ((int64_t)*p++) << 48;
1158 l += ((int64_t)*p++) << 56;
1164 /* If the relocation is internal add to the current section
1165 offset. Otherwise the only value we need is the symbol
1166 offset which we already have. The linker takes care
1167 of the rest of the address. */
1168 if (!r->ext) {
1169 /* generate final address by section address and offset */
1170 for (s2 = sects, fi = 1;
1171 s2 != NULL; s2 = s2->next, fi++) {
1172 if (fi == r->snum) {
1173 l += s2->addr;
1174 break;
1179 /* write new offset back */
1180 if (r->length == 3)
1181 WRITEDLONG(q, l);
1182 else if (r->length == 2)
1183 WRITELONG(q, l);
1184 else if (r->length == 1)
1185 WRITESHORT(q, l);
1186 else
1187 *q++ = l & 0xFF;
1189 saa_fwrite(s->data, r->addr, blk, len);
1192 /* dump the section data to file */
1193 saa_fpwrite(s->data, ofile);
1196 /* pad last section up to reloc entries on int64_t boundary */
1197 fwritezero(rel_padcnt64, ofile);
1199 /* emit relocation entries */
1200 for (s = sects; s != NULL; s = s->next)
1201 macho_write_relocs (s->relocs);
1204 /* Write out the symbol table. We should already have sorted this
1205 before now. */
1206 static void macho_write_symtab (void)
1208 struct symbol *sym;
1209 struct section *s;
1210 int64_t fi;
1211 uint64_t i;
1213 /* we don't need to pad here since MACHO_RELINFO_SIZE == 8 */
1215 for (sym = syms; sym != NULL; sym = sym->next) {
1216 if ((sym->type & N_EXT) == 0) {
1217 fwriteint32_t(sym->strx, ofile); /* string table entry number */
1218 fwrite(&sym->type, 1, 1, ofile); /* symbol type */
1219 fwrite(&sym->sect, 1, 1, ofile); /* section */
1220 fwriteint16_t(sym->desc, ofile); /* description */
1222 /* Fix up the symbol value now that we know the final section
1223 sizes. */
1224 if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
1225 for (s = sects, fi = 1; s != NULL; s = s->next, fi++) {
1226 if (fi == sym->sect) {
1227 sym->value += s->addr;
1228 break;
1233 fwriteint64_t(sym->value, ofile); /* value (i.e. offset) */
1237 for (i = 0; i < nextdefsym; i++) {
1238 sym = extdefsyms[i];
1239 fwriteint32_t(sym->strx, ofile);
1240 fwrite(&sym->type, 1, 1, ofile); /* symbol type */
1241 fwrite(&sym->sect, 1, 1, ofile); /* section */
1242 fwriteint16_t(sym->desc, ofile); /* description */
1244 /* Fix up the symbol value now that we know the final section
1245 sizes. */
1246 if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
1247 for (s = sects, fi = 1;
1248 s != NULL && fi < sym->sect; s = s->next, ++fi)
1249 sym->value += s->size;
1252 fwriteint64_t(sym->value, ofile); /* value (i.e. offset) */
1255 for (i = 0; i < nundefsym; i++) {
1256 sym = undefsyms[i];
1257 fwriteint32_t(sym->strx, ofile);
1258 fwrite(&sym->type, 1, 1, ofile); /* symbol type */
1259 fwrite(&sym->sect, 1, 1, ofile); /* section */
1260 fwriteint16_t(sym->desc, ofile); /* description */
1262 // Fix up the symbol value now that we know the final section sizes.
1263 if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
1264 for (s = sects, fi = 1;
1265 s != NULL && fi < sym->sect; s = s->next, ++fi)
1266 sym->value += s->size;
1269 fwriteint64_t(sym->value, ofile); // value (i.e. offset)
1274 /* Fixup the snum in the relocation entries, we should be
1275 doing this only for externally referenced symbols. */
1276 static void macho_fixup_relocs (struct reloc *r)
1278 struct symbol *sym;
1280 while (r != NULL) {
1281 if (r->ext) {
1282 for (sym = syms; sym != NULL; sym = sym->next) {
1283 if (sym->initial_snum == r->snum) {
1284 r->snum = sym->snum;
1285 break;
1289 r = r->next;
1293 /* Write out the object file. */
1295 static void macho_write (void)
1297 uint64_t offset = 0;
1299 /* mach-o object file structure:
1301 ** mach header
1302 ** uint32_t magic
1303 ** int cpu type
1304 ** int cpu subtype
1305 ** uint32_t mach file type
1306 ** uint32_t number of load commands
1307 ** uint32_t size of all load commands
1308 ** (includes section struct size of segment command)
1309 ** uint32_t flags
1311 ** segment command
1312 ** uint32_t command type == LC_SEGMENT_64
1313 ** uint32_t size of load command
1314 ** (including section load commands)
1315 ** char[16] segment name
1316 ** uint64_t in-memory offset
1317 ** uint64_t in-memory size
1318 ** uint64_t in-file offset to data area
1319 ** uint64_t in-file size
1320 ** (in-memory size excluding zerofill sections)
1321 ** int maximum vm protection
1322 ** int initial vm protection
1323 ** uint32_t number of sections
1324 ** uint32_t flags
1326 ** section commands
1327 ** char[16] section name
1328 ** char[16] segment name
1329 ** uint64_t in-memory offset
1330 ** uint64_t in-memory size
1331 ** uint32_t in-file offset
1332 ** uint32_t alignment
1333 ** (irrelevant in MH_OBJECT)
1334 ** uint32_t in-file offset of relocation entires
1335 ** uint32_t number of relocations
1336 ** uint32_t flags
1337 ** uint32_t reserved
1338 ** uint32_t reserved
1340 ** symbol table command
1341 ** uint32_t command type == LC_SYMTAB
1342 ** uint32_t size of load command
1343 ** uint32_t symbol table offset
1344 ** uint32_t number of symbol table entries
1345 ** uint32_t string table offset
1346 ** uint32_t string table size
1348 ** raw section data
1350 ** padding to int64_t boundary
1352 ** relocation data (struct reloc)
1353 ** int32_t offset
1354 ** uint data (symbolnum, pcrel, length, extern, type)
1356 ** symbol table data (struct nlist)
1357 ** int32_t string table entry number
1358 ** uint8_t type
1359 ** (extern, absolute, defined in section)
1360 ** uint8_t section
1361 ** (0 for global symbols, section number of definition (>= 1, <=
1362 ** 254) for local symbols, size of variable for common symbols
1363 ** [type == extern])
1364 ** int16_t description
1365 ** (for stab debugging format)
1366 ** uint64_t value (i.e. file offset) of symbol or stab offset
1368 ** string table data
1369 ** list of null-terminated strings
1372 /* Emit the Mach-O header. */
1373 macho_write_header();
1375 offset = MACHO_HEADER64_SIZE + head_sizeofcmds64;
1377 /* emit the segment load command */
1378 if (seg_nsects64 > 0)
1379 offset = macho_write_segment (offset);
1380 else
1381 nasm_error(ERR_WARNING, "no sections?");
1383 if (nsyms > 0) {
1384 /* write out symbol command */
1385 fwriteint32_t(LC_SYMTAB, ofile); /* cmd == LC_SYMTAB */
1386 fwriteint32_t(MACHO_SYMCMD_SIZE, ofile); /* size of load command */
1387 fwriteint32_t(offset, ofile); /* symbol table offset */
1388 fwriteint32_t(nsyms, ofile); /* number of symbol
1389 ** table entries */
1391 offset += nsyms * MACHO_NLIST64_SIZE;
1392 fwriteint32_t(offset, ofile); /* string table offset */
1393 fwriteint32_t(strslen, ofile); /* string table size */
1396 /* emit section data */
1397 if (seg_nsects64 > 0)
1398 macho_write_section ();
1400 /* emit symbol table if we have symbols */
1401 if (nsyms > 0)
1402 macho_write_symtab ();
1404 /* we don't need to pad here since MACHO_NLIST64_SIZE == 16 */
1406 /* emit string table */
1407 saa_fpwrite(strs, ofile);
1409 /* We do quite a bit here, starting with finalizing all of the data
1410 for the object file, writing, and then freeing all of the data from
1411 the file. */
1413 static void macho_cleanup(int debuginfo)
1415 struct section *s;
1416 struct reloc *r;
1417 struct symbol *sym;
1419 (void)debuginfo;
1421 /* Sort all symbols. */
1422 macho_layout_symbols (&nsyms, &strslen);
1424 /* Fixup relocation entries */
1425 for (s = sects; s != NULL; s = s->next) {
1426 macho_fixup_relocs (s->relocs);
1429 /* First calculate and finalize needed values. */
1430 macho_calculate_sizes();
1431 macho_write();
1433 /* free up everything */
1434 while (sects->next) {
1435 s = sects;
1436 sects = sects->next;
1438 saa_free(s->data);
1439 while (s->relocs != NULL) {
1440 r = s->relocs;
1441 s->relocs = s->relocs->next;
1442 nasm_free(r);
1445 nasm_free(s);
1448 saa_free(strs);
1449 raa_free(extsyms);
1451 if (syms) {
1452 while (syms->next) {
1453 sym = syms;
1454 syms = syms->next;
1456 nasm_free (sym);
1461 /* Debugging routines. */
1462 static void debug_reloc (struct reloc *r)
1464 fprintf (stdout, "reloc:\n");
1465 fprintf (stdout, "\taddr: %"PRId32"\n", r->addr);
1466 fprintf (stdout, "\tsnum: %d\n", r->snum);
1467 fprintf (stdout, "\tpcrel: %d\n", r->pcrel);
1468 fprintf (stdout, "\tlength: %d\n", r->length);
1469 fprintf (stdout, "\text: %d\n", r->ext);
1470 fprintf (stdout, "\ttype: %d\n", r->type);
1473 static void debug_section_relocs (struct section *s)
1475 struct reloc *r = s->relocs;
1477 fprintf (stdout, "relocs for section %s:\n\n", s->sectname);
1479 while (r != NULL) {
1480 debug_reloc (r);
1481 r = r->next;
1485 struct ofmt of_macho64 = {
1486 "NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X (x86_64) object files",
1487 "macho64",
1489 null_debug_arr,
1490 &null_debug_form,
1491 macho_stdmac,
1492 macho_init,
1493 null_setinfo,
1494 macho_output,
1495 macho_symdef,
1496 macho_section,
1497 macho_sectalign,
1498 macho_segbase,
1499 null_directive,
1500 macho_filename,
1501 macho_cleanup
1504 #endif
1507 * Local Variables:
1508 * mode:c
1509 * c-basic-offset:4
1510 * End:
1512 * end of file */