preproc: Drop never used pp_runtime
[nasm/sigaren-mirror.git] / output / outmac32.c
bloba13e0d9b9c731a8eca12af611f800c3e97e5b1a8
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 * outmacho.c output routines for the Netwide Assembler to produce
36 * NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X 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 "eval.h"
55 #include "output/outform.h"
56 #include "output/outlib.h"
58 #if defined(OF_MACHO32)
60 /* Mach-O in-file header structure sizes */
61 #define MACHO_HEADER_SIZE (28)
62 #define MACHO_SEGCMD_SIZE (56)
63 #define MACHO_SECTCMD_SIZE (68)
64 #define MACHO_SYMCMD_SIZE (24)
65 #define MACHO_NLIST_SIZE (12)
66 #define MACHO_RELINFO_SIZE (8)
68 /* Mach-O file header values */
69 #define MH_MAGIC (0xfeedface)
70 #define CPU_TYPE_I386 (7) /* x86 platform */
71 #define CPU_SUBTYPE_I386_ALL (3) /* all-x86 compatible */
72 #define MH_OBJECT (0x1) /* object file */
74 #define LC_SEGMENT (0x1) /* segment load command */
75 #define LC_SYMTAB (0x2) /* symbol table load command */
77 #define VM_PROT_NONE (0x00)
78 #define VM_PROT_READ (0x01)
79 #define VM_PROT_WRITE (0x02)
80 #define VM_PROT_EXECUTE (0x04)
82 #define VM_PROT_DEFAULT (VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE)
83 #define VM_PROT_ALL (VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE)
85 struct section {
86 /* nasm internal data */
87 struct section *next;
88 struct SAA *data;
89 int32_t index;
90 struct reloc *relocs;
91 int align;
93 /* data that goes into the file */
94 char sectname[16]; /* what this section is called */
95 char segname[16]; /* segment this section will be in */
96 uint32_t addr; /* in-memory address (subject to alignment) */
97 uint32_t size; /* in-memory and -file size */
98 uint32_t nreloc; /* relocation entry count */
99 uint32_t flags; /* type and attributes (masked) */
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 */
116 static struct sectmap {
117 const char *nasmsect;
118 const char *segname;
119 const char *sectname;
120 const int32_t flags;
121 } sectmap[] = {
122 {".text", "__TEXT", "__text", S_REGULAR|S_ATTR_SOME_INSTRUCTIONS},
123 {".data", "__DATA", "__data", S_REGULAR},
124 {".rodata", "__DATA", "__const", S_REGULAR},
125 {".bss", "__DATA", "__bss", S_ZEROFILL},
126 {NULL, NULL, NULL, 0}
129 struct reloc {
130 /* nasm internal data */
131 struct reloc *next;
133 /* data that goes into the file */
134 int32_t addr; /* op's offset in section */
135 unsigned int snum:24, /* contains symbol index if
136 ** ext otherwise in-file
137 ** section number */
138 pcrel:1, /* relative relocation */
139 length:2, /* 0=byte, 1=word, 2=int32_t */
140 ext:1, /* external symbol referenced */
141 type:4; /* reloc type, 0 for us */
144 #define R_ABS 0 /* absolute relocation */
145 #define R_SCATTERED 0x80000000 /* reloc entry is scattered if
146 ** highest bit == 1 */
148 struct symbol {
149 /* nasm internal data */
150 struct symbol *next; /* next symbol in the list */
151 char *name; /* name of this symbol */
152 int32_t initial_snum; /* symbol number used above in
153 reloc */
154 int32_t snum; /* true snum for reloc */
156 /* data that goes into the file */
157 int32_t strx; /* string table index */
158 uint8_t type; /* symbol type */
159 uint8_t sect; /* NO_SECT or section number */
160 int16_t desc; /* for stab debugging, 0 for us */
161 uint32_t value; /* offset of symbol in section */
164 /* symbol type bits */
165 #define N_EXT 0x01 /* global or external symbol */
167 #define N_UNDF 0x0 /* undefined symbol | n_sect == */
168 #define N_ABS 0x2 /* absolute symbol | NO_SECT */
169 #define N_SECT 0xe /* defined symbol, n_sect holds
170 ** section number */
172 #define N_TYPE 0x0e /* type bit mask */
174 #define DEFAULT_SECTION_ALIGNMENT 0 /* byte (i.e. no) alignment */
176 /* special section number values */
177 #define NO_SECT 0 /* no section, invalid */
178 #define MAX_SECT 255 /* maximum number of sections */
180 static struct section *sects, **sectstail;
181 static struct symbol *syms, **symstail;
182 static uint32_t nsyms;
184 /* These variables are set by macho_layout_symbols() to organize
185 the symbol table and string table in order the dynamic linker
186 expects. They are then used in macho_write() to put out the
187 symbols and strings in that order.
189 The order of the symbol table is:
190 local symbols
191 defined external symbols (sorted by name)
192 undefined external symbols (sorted by name)
194 The order of the string table is:
195 strings for external symbols
196 strings for local symbols
198 static uint32_t ilocalsym = 0;
199 static uint32_t iextdefsym = 0;
200 static uint32_t iundefsym = 0;
201 static uint32_t nlocalsym;
202 static uint32_t nextdefsym;
203 static uint32_t nundefsym;
204 static struct symbol **extdefsyms = NULL;
205 static struct symbol **undefsyms = NULL;
207 static struct RAA *extsyms;
208 static struct SAA *strs;
209 static uint32_t strslen;
211 /* Global file information. This should be cleaned up into either
212 a structure or as function arguments. */
213 uint32_t head_ncmds = 0;
214 uint32_t head_sizeofcmds = 0;
215 uint32_t seg_filesize = 0;
216 uint32_t seg_vmsize = 0;
217 uint32_t seg_nsects = 0;
218 uint32_t rel_padcnt = 0;
221 #define xstrncpy(xdst, xsrc) \
222 memset(xdst, '\0', sizeof(xdst)); /* zero out whole buffer */ \
223 strncpy(xdst, xsrc, sizeof(xdst)); /* copy over string */ \
224 xdst[sizeof(xdst) - 1] = '\0'; /* proper null-termination */
226 #define alignint32_t(x) \
227 ALIGN(x, sizeof(int32_t)) /* align x to int32_t boundary */
229 static void debug_reloc (struct reloc *);
230 static void debug_section_relocs (struct section *) _unused;
232 static struct section *get_section_by_name(const char *segname,
233 const char *sectname)
235 struct section *s;
237 for (s = sects; s != NULL; s = s->next)
238 if (!strcmp(s->segname, segname) && !strcmp(s->sectname, sectname))
239 break;
241 return s;
244 static struct section *get_section_by_index(const int32_t index)
246 struct section *s;
248 for (s = sects; s != NULL; s = s->next)
249 if (index == s->index)
250 break;
252 return s;
255 static int32_t get_section_index_by_name(const char *segname,
256 const char *sectname)
258 struct section *s;
260 for (s = sects; s != NULL; s = s->next)
261 if (!strcmp(s->segname, segname) && !strcmp(s->sectname, sectname))
262 return s->index;
264 return -1;
267 static char *get_section_name_by_index(const int32_t index)
269 struct section *s;
271 for (s = sects; s != NULL; s = s->next)
272 if (index == s->index)
273 return s->sectname;
275 return NULL;
278 static uint8_t get_section_fileindex_by_index(const int32_t index)
280 struct section *s;
281 uint8_t i = 1;
283 for (s = sects; s != NULL && i < MAX_SECT; s = s->next, ++i)
284 if (index == s->index)
285 return i;
287 if (i == MAX_SECT)
288 nasm_error(ERR_WARNING,
289 "too many sections (>255) - clipped by fileindex");
291 return NO_SECT;
294 static void macho_init(void)
296 char zero = 0;
298 sects = NULL;
299 sectstail = &sects;
301 syms = NULL;
302 symstail = &syms;
303 nsyms = 0;
304 nlocalsym = 0;
305 nextdefsym = 0;
306 nundefsym = 0;
308 extsyms = raa_init();
309 strs = saa_init(1L);
311 /* string table starts with a zero byte - don't ask why */
312 saa_wbytes(strs, &zero, sizeof(char));
313 strslen = 1;
316 static void sect_write(struct section *sect,
317 const uint8_t *data, uint32_t len)
319 saa_wbytes(sect->data, data, len);
320 sect->size += len;
323 static void add_reloc(struct section *sect, int32_t section,
324 int pcrel, int bytes)
326 struct reloc *r;
327 int32_t fi;
329 /* NeXT as puts relocs in reversed order (address-wise) into the
330 ** files, so we do the same, doesn't seem to make much of a
331 ** difference either way */
332 r = nasm_malloc(sizeof(struct reloc));
333 r->next = sect->relocs;
334 sect->relocs = r;
336 /* the current end of the section will be the symbol's address for
337 ** now, might have to be fixed by macho_fixup_relocs() later on. make
338 ** sure we don't make the symbol scattered by setting the highest
339 ** bit by accident */
340 r->addr = sect->size & ~R_SCATTERED;
341 r->ext = 0;
342 r->pcrel = pcrel;
344 /* match byte count 1, 2, 4 to length codes 0, 1, 2 respectively */
345 r->length = bytes >> 1;
347 /* vanilla relocation (GENERIC_RELOC_VANILLA) */
348 r->type = 0;
350 if (section == NO_SEG) {
351 /* absolute local symbol if no section index given */
352 r->snum = R_ABS;
353 } else {
354 fi = get_section_fileindex_by_index(section);
356 if (fi == NO_SECT) {
357 /* external symbol if no section with that index known,
358 ** symbol number was saved in macho_symdef() */
359 r->snum = raa_read(extsyms, section);
360 r->ext = 1;
361 } else {
362 /* local symbol in section fi */
363 r->snum = fi;
367 ++sect->nreloc;
370 static void macho_output(int32_t secto, const void *data,
371 enum out_type type, uint64_t size,
372 int32_t section, int32_t wrt)
374 struct section *s, *sbss;
375 int32_t addr;
376 uint8_t mydata[4], *p;
378 if (wrt != NO_SEG) {
379 wrt = NO_SEG;
380 nasm_error(ERR_NONFATAL, "WRT not supported by Mach-O output format");
381 /* continue to do _something_ */
384 if (secto == NO_SEG) {
385 if (type != OUT_RESERVE)
386 nasm_error(ERR_NONFATAL, "attempt to assemble code in "
387 "[ABSOLUTE] space");
389 return;
392 s = get_section_by_index(secto);
394 if (s == NULL) {
395 nasm_error(ERR_WARNING, "attempt to assemble code in"
396 " section %d: defaulting to `.text'", secto);
397 s = get_section_by_name("__TEXT", "__text");
399 /* should never happen */
400 if (s == NULL)
401 nasm_error(ERR_PANIC, "text section not found");
404 sbss = get_section_by_name("__DATA", "__bss");
406 if (s == sbss && type != OUT_RESERVE) {
407 nasm_error(ERR_WARNING, "attempt to initialize memory in the"
408 " BSS section: ignored");
409 s->size += realsize(type, size);
410 return;
413 switch (type) {
414 case OUT_RESERVE:
415 if (s != sbss) {
416 nasm_error(ERR_WARNING, "uninitialized space declared in"
417 " %s section: zeroing",
418 get_section_name_by_index(secto));
420 sect_write(s, NULL, size);
421 } else
422 s->size += size;
424 break;
426 case OUT_RAWDATA:
427 if (section != NO_SEG)
428 nasm_error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
430 sect_write(s, data, size);
431 break;
433 case OUT_ADDRESS:
434 addr = *(int64_t *)data;
436 if (section != NO_SEG) {
437 if (section % 2) {
438 nasm_error(ERR_NONFATAL, "Mach-O format does not support"
439 " section base references");
440 } else
441 add_reloc(s, section, 0, size);
444 p = mydata;
445 WRITEADDR(p, addr, size);
446 sect_write(s, mydata, size);
447 break;
449 case OUT_REL2ADR:
450 if (section == secto)
451 nasm_error(ERR_PANIC, "intra-section OUT_REL2ADR");
453 if (section != NO_SEG && section % 2) {
454 nasm_error(ERR_NONFATAL, "Mach-O format does not support"
455 " section base references");
456 } else
457 add_reloc(s, section, 1, 2);
459 p = mydata;
460 WRITESHORT(p, *(int32_t *)data - (size + s->size));
461 sect_write(s, mydata, 2L);
462 break;
464 case OUT_REL4ADR:
465 if (section == secto)
466 nasm_error(ERR_PANIC, "intra-section OUT_REL4ADR");
468 if (section != NO_SEG && section % 2) {
469 nasm_error(ERR_NONFATAL, "Mach-O format does not support"
470 " section base references");
471 } else
472 add_reloc(s, section, 1, 4);
474 p = mydata;
475 WRITELONG(p, *(int32_t *)data - (size + s->size));
476 sect_write(s, mydata, 4L);
477 break;
479 default:
480 nasm_error(ERR_PANIC, "unknown output type?");
481 break;
485 static int32_t macho_section(char *name, int pass, int *bits)
487 int32_t index, originalIndex;
488 char *sectionAttributes;
489 struct sectmap *sm;
490 struct section *s;
492 (void)pass;
494 /* Default to 32 bits. */
495 if (!name) {
496 *bits = 32;
497 name = ".text";
498 sectionAttributes = NULL;
499 } else {
500 sectionAttributes = name;
501 name = nasm_strsep(&sectionAttributes, " \t");
504 for (sm = sectmap; sm->nasmsect != NULL; ++sm) {
505 /* make lookup into section name translation table */
506 if (!strcmp(name, sm->nasmsect)) {
507 char *currentAttribute;
509 /* try to find section with that name */
510 originalIndex = index = get_section_index_by_name(sm->segname,
511 sm->sectname);
513 /* create it if it doesn't exist yet */
514 if (index == -1) {
515 s = *sectstail = nasm_malloc(sizeof(struct section));
516 s->next = NULL;
517 sectstail = &s->next;
519 s->data = saa_init(1L);
520 s->index = seg_alloc();
521 s->relocs = NULL;
522 s->align = -1;
524 xstrncpy(s->segname, sm->segname);
525 xstrncpy(s->sectname, sm->sectname);
526 s->size = 0;
527 s->nreloc = 0;
528 s->flags = sm->flags;
530 index = s->index;
531 } else {
532 s = get_section_by_index(index);
535 while ((NULL != sectionAttributes)
536 && (currentAttribute = nasm_strsep(&sectionAttributes, " \t"))) {
537 if (0 != *currentAttribute) {
538 if (!nasm_strnicmp("align=", currentAttribute, 6)) {
539 char *end;
540 int newAlignment, value;
542 value = strtoul(currentAttribute + 6, (char**)&end, 0);
543 newAlignment = alignlog2_32(value);
545 if (0 != *end) {
546 nasm_error(ERR_PANIC,
547 "unknown or missing alignment value \"%s\" "
548 "specified for section \"%s\"",
549 currentAttribute + 6,
550 name);
551 return NO_SEG;
552 } else if (0 > newAlignment) {
553 nasm_error(ERR_PANIC,
554 "alignment of %d (for section \"%s\") is not "
555 "a power of two",
556 value,
557 name);
558 return NO_SEG;
561 if ((-1 != originalIndex)
562 && (s->align != newAlignment)
563 && (s->align != -1)) {
564 nasm_error(ERR_PANIC,
565 "section \"%s\" has already been specified "
566 "with alignment %d, conflicts with new "
567 "alignment of %d",
568 name,
569 (1 << s->align),
570 value);
571 return NO_SEG;
574 s->align = newAlignment;
575 } else if (!nasm_stricmp("data", currentAttribute)) {
576 /* Do nothing; 'data' is implicit */
577 } else {
578 nasm_error(ERR_PANIC,
579 "unknown section attribute %s for section %s",
580 currentAttribute,
581 name);
582 return NO_SEG;
587 return index;
591 nasm_error(ERR_PANIC, "invalid section name %s", name);
592 return NO_SEG;
595 static void macho_symdef(char *name, int32_t section, int64_t offset,
596 int is_global, char *special)
598 struct symbol *sym;
600 if (special) {
601 nasm_error(ERR_NONFATAL, "The Mach-O output format does "
602 "not support any special symbol types");
603 return;
606 if (is_global == 3) {
607 nasm_error(ERR_NONFATAL, "The Mach-O format does not "
608 "(yet) support forward reference fixups.");
609 return;
612 sym = *symstail = nasm_malloc(sizeof(struct symbol));
613 sym->next = NULL;
614 symstail = &sym->next;
616 sym->name = name;
617 sym->strx = strslen;
618 sym->type = 0;
619 sym->desc = 0;
620 sym->value = offset;
621 sym->initial_snum = -1;
623 /* external and common symbols get N_EXT */
624 if (is_global != 0)
625 sym->type |= N_EXT;
627 if (section == NO_SEG) {
628 /* symbols in no section get absolute */
629 sym->type |= N_ABS;
630 sym->sect = NO_SECT;
631 } else {
632 sym->type |= N_SECT;
634 /* get the in-file index of the section the symbol was defined in */
635 sym->sect = get_section_fileindex_by_index(section);
637 if (sym->sect == NO_SECT) {
638 /* remember symbol number of references to external
639 ** symbols, this works because every external symbol gets
640 ** its own section number allocated internally by nasm and
641 ** can so be used as a key */
642 extsyms = raa_write(extsyms, section, nsyms);
643 sym->initial_snum = nsyms;
645 switch (is_global) {
646 case 1:
647 case 2:
648 /* there isn't actually a difference between global
649 ** and common symbols, both even have their size in
650 ** sym->value */
651 sym->type = N_EXT;
652 break;
654 default:
655 /* give an error on unfound section if it's not an
656 ** external or common symbol (assemble_file() does a
657 ** seg_alloc() on every call for them) */
658 nasm_error(ERR_PANIC, "in-file index for section %d not found",
659 section);
664 ++nsyms;
667 static void macho_sectalign(int32_t seg, unsigned int value)
669 struct section *s;
671 list_for_each(s, sects) {
672 if (s->index == seg)
673 break;
676 if (!s || !is_power2(value))
677 return;
679 value = alignlog2_32(value);
680 if (s->align < (int)value)
681 s->align = value;
684 static int32_t macho_segbase(int32_t section)
686 return section;
689 static void macho_filename(char *inname, char *outname)
691 standard_extension(inname, outname, ".o");
694 extern macros_t macho_stdmac[];
696 /* Comparison function for qsort symbol layout. */
697 static int layout_compare (const struct symbol **s1,
698 const struct symbol **s2)
700 return (strcmp ((*s1)->name, (*s2)->name));
703 /* The native assembler does a few things in a similar function
705 * Remove temporary labels
706 * Sort symbols according to local, external, undefined (by name)
707 * Order the string table
709 We do not remove temporary labels right now.
711 numsyms is the total number of symbols we have. strtabsize is the
712 number entries in the string table. */
714 static void macho_layout_symbols (uint32_t *numsyms,
715 uint32_t *strtabsize)
717 struct symbol *sym, **symp;
718 uint32_t i,j;
720 *numsyms = 0;
721 *strtabsize = sizeof (char);
723 symp = &syms;
725 while ((sym = *symp)) {
726 /* Undefined symbols are now external. */
727 if (sym->type == N_UNDF)
728 sym->type |= N_EXT;
730 if ((sym->type & N_EXT) == 0) {
731 sym->snum = *numsyms;
732 *numsyms = *numsyms + 1;
733 nlocalsym++;
735 else {
736 if ((sym->type & N_TYPE) != N_UNDF)
737 nextdefsym++;
738 else
739 nundefsym++;
741 /* If we handle debug info we'll want
742 to check for it here instead of just
743 adding the symbol to the string table. */
744 sym->strx = *strtabsize;
745 saa_wbytes (strs, sym->name, (int32_t)(strlen(sym->name) + 1));
746 *strtabsize += strlen(sym->name) + 1;
748 symp = &(sym->next);
751 /* Next, sort the symbols. Most of this code is a direct translation from
752 the Apple cctools symbol layout. We need to keep compatibility with that. */
753 /* Set the indexes for symbol groups into the symbol table */
754 ilocalsym = 0;
755 iextdefsym = nlocalsym;
756 iundefsym = nlocalsym + nextdefsym;
758 /* allocate arrays for sorting externals by name */
759 extdefsyms = nasm_malloc(nextdefsym * sizeof(struct symbol *));
760 undefsyms = nasm_malloc(nundefsym * sizeof(struct symbol *));
762 i = 0;
763 j = 0;
765 symp = &syms;
767 while ((sym = *symp)) {
769 if((sym->type & N_EXT) == 0) {
770 sym->strx = *strtabsize;
771 saa_wbytes (strs, sym->name, (int32_t)(strlen (sym->name) + 1));
772 *strtabsize += strlen(sym->name) + 1;
774 else {
775 if((sym->type & N_TYPE) != N_UNDF)
776 extdefsyms[i++] = sym;
777 else
778 undefsyms[j++] = sym;
780 symp = &(sym->next);
783 qsort(extdefsyms, nextdefsym, sizeof(struct symbol *),
784 (int (*)(const void *, const void *))layout_compare);
785 qsort(undefsyms, nundefsym, sizeof(struct symbol *),
786 (int (*)(const void *, const void *))layout_compare);
788 for(i = 0; i < nextdefsym; i++) {
789 extdefsyms[i]->snum = *numsyms;
790 *numsyms += 1;
792 for(j = 0; j < nundefsym; j++) {
793 undefsyms[j]->snum = *numsyms;
794 *numsyms += 1;
798 /* Calculate some values we'll need for writing later. */
800 static void macho_calculate_sizes (void)
802 struct section *s;
804 /* count sections and calculate in-memory and in-file offsets */
805 for (s = sects; s != NULL; s = s->next) {
806 uint32_t pad = 0;
808 /* zerofill sections aren't actually written to the file */
809 if ((s->flags & SECTION_TYPE) != S_ZEROFILL)
810 seg_filesize += s->size;
812 /* recalculate segment address based on alignment and vm size */
813 s->addr = seg_vmsize;
814 /* we need section alignment to calculate final section address */
815 if (s->align == -1)
816 s->align = DEFAULT_SECTION_ALIGNMENT;
817 if(s->align) {
818 uint32_t newaddr = ALIGN(s->addr, 1 << s->align);
819 pad = newaddr - s->addr;
820 s->addr = newaddr;
823 seg_vmsize += s->size + pad;
824 ++seg_nsects;
827 /* calculate size of all headers, load commands and sections to
828 ** get a pointer to the start of all the raw data */
829 if (seg_nsects > 0) {
830 ++head_ncmds;
831 head_sizeofcmds +=
832 MACHO_SEGCMD_SIZE + seg_nsects * MACHO_SECTCMD_SIZE;
835 if (nsyms > 0) {
836 ++head_ncmds;
837 head_sizeofcmds += MACHO_SYMCMD_SIZE;
841 /* Write out the header information for the file. */
843 static void macho_write_header (void)
845 fwriteint32_t(MH_MAGIC, ofile); /* magic */
846 fwriteint32_t(CPU_TYPE_I386, ofile); /* CPU type */
847 fwriteint32_t(CPU_SUBTYPE_I386_ALL, ofile); /* CPU subtype */
848 fwriteint32_t(MH_OBJECT, ofile); /* Mach-O file type */
849 fwriteint32_t(head_ncmds, ofile); /* number of load commands */
850 fwriteint32_t(head_sizeofcmds, ofile); /* size of load commands */
851 fwriteint32_t(0, ofile); /* no flags */
854 /* Write out the segment load command at offset. */
856 static uint32_t macho_write_segment (uint32_t offset)
858 uint32_t rel_base = alignint32_t (offset + seg_filesize);
859 uint32_t s_reloff = 0;
860 struct section *s;
862 fwriteint32_t(LC_SEGMENT, ofile); /* cmd == LC_SEGMENT */
864 /* size of load command including section load commands */
865 fwriteint32_t(MACHO_SEGCMD_SIZE + seg_nsects *
866 MACHO_SECTCMD_SIZE, ofile);
868 /* in an MH_OBJECT file all sections are in one unnamed (name
869 ** all zeros) segment */
870 fwritezero(16, ofile);
871 fwriteint32_t(0, ofile); /* in-memory offset */
872 fwriteint32_t(seg_vmsize, ofile); /* in-memory size */
873 fwriteint32_t(offset, ofile); /* in-file offset to data */
874 fwriteint32_t(seg_filesize, ofile); /* in-file size */
875 fwriteint32_t(VM_PROT_DEFAULT, ofile); /* maximum vm protection */
876 fwriteint32_t(VM_PROT_DEFAULT, ofile); /* initial vm protection */
877 fwriteint32_t(seg_nsects, ofile); /* number of sections */
878 fwriteint32_t(0, ofile); /* no flags */
880 /* emit section headers */
881 for (s = sects; s != NULL; s = s->next) {
882 fwrite(s->sectname, sizeof(s->sectname), 1, ofile);
883 fwrite(s->segname, sizeof(s->segname), 1, ofile);
884 fwriteint32_t(s->addr, ofile);
885 fwriteint32_t(s->size, ofile);
887 /* dummy data for zerofill sections or proper values */
888 if ((s->flags & SECTION_TYPE) != S_ZEROFILL) {
889 fwriteint32_t(offset, ofile);
890 /* Write out section alignment, as a power of two.
891 e.g. 32-bit word alignment would be 2 (2^^2 = 4). */
892 if (s->align == -1)
893 s->align = DEFAULT_SECTION_ALIGNMENT;
894 fwriteint32_t(s->align, ofile);
895 /* To be compatible with cctools as we emit
896 a zero reloff if we have no relocations. */
897 fwriteint32_t(s->nreloc ? rel_base + s_reloff : 0, ofile);
898 fwriteint32_t(s->nreloc, ofile);
900 offset += s->size;
901 s_reloff += s->nreloc * MACHO_RELINFO_SIZE;
902 } else {
903 fwriteint32_t(0, ofile);
904 fwriteint32_t(0, ofile);
905 fwriteint32_t(0, ofile);
906 fwriteint32_t(0, ofile);
909 fwriteint32_t(s->flags, ofile); /* flags */
910 fwriteint32_t(0, ofile); /* reserved */
911 fwriteint32_t(0, ofile); /* reserved */
914 rel_padcnt = rel_base - offset;
915 offset = rel_base + s_reloff;
917 return offset;
920 /* For a given chain of relocs r, write out the entire relocation
921 chain to the object file. */
923 static void macho_write_relocs (struct reloc *r)
925 while (r) {
926 uint32_t word2;
928 fwriteint32_t(r->addr, ofile); /* reloc offset */
930 word2 = r->snum;
931 word2 |= r->pcrel << 24;
932 word2 |= r->length << 25;
933 word2 |= r->ext << 27;
934 word2 |= r->type << 28;
935 fwriteint32_t(word2, ofile); /* reloc data */
937 r = r->next;
941 /* Write out the section data. */
942 static void macho_write_section (void)
944 struct section *s, *s2;
945 struct reloc *r;
946 uint8_t fi, *p, *q, blk[4];
947 int32_t l;
949 for (s = sects; s != NULL; s = s->next) {
950 if ((s->flags & SECTION_TYPE) == S_ZEROFILL)
951 continue;
953 /* no padding needs to be done to the sections */
955 /* Like a.out Mach-O references things in the data or bss
956 * sections by addresses which are actually relative to the
957 * start of the _text_ section, in the _file_. See outaout.c
958 * for more information. */
959 saa_rewind(s->data);
960 for (r = s->relocs; r != NULL; r = r->next) {
961 saa_fread(s->data, r->addr, blk, (int32_t)r->length << 1);
962 p = q = blk;
963 l = *p++;
965 /* get offset based on relocation type */
966 if (r->length > 0) {
967 l += ((int32_t)*p++) << 8;
969 if (r->length == 2) {
970 l += ((int32_t)*p++) << 16;
971 l += ((int32_t)*p++) << 24;
975 /* If the relocation is internal add to the current section
976 offset. Otherwise the only value we need is the symbol
977 offset which we already have. The linker takes care
978 of the rest of the address. */
979 if (!r->ext) {
980 /* generate final address by section address and offset */
981 for (s2 = sects, fi = 1;
982 s2 != NULL; s2 = s2->next, fi++) {
983 if (fi == r->snum) {
984 l += s2->addr;
985 break;
990 /* write new offset back */
991 if (r->length == 2)
992 WRITELONG(q, l);
993 else if (r->length == 1)
994 WRITESHORT(q, l);
995 else
996 *q++ = l & 0xFF;
998 saa_fwrite(s->data, r->addr, blk, (int32_t)r->length << 1);
1001 /* dump the section data to file */
1002 saa_fpwrite(s->data, ofile);
1005 /* pad last section up to reloc entries on int32_t boundary */
1006 fwritezero(rel_padcnt, ofile);
1008 /* emit relocation entries */
1009 for (s = sects; s != NULL; s = s->next)
1010 macho_write_relocs (s->relocs);
1013 /* Write out the symbol table. We should already have sorted this
1014 before now. */
1015 static void macho_write_symtab (void)
1017 struct symbol *sym;
1018 struct section *s;
1019 int32_t fi;
1020 uint32_t i;
1022 /* we don't need to pad here since MACHO_RELINFO_SIZE == 8 */
1024 for (sym = syms; sym != NULL; sym = sym->next) {
1025 if ((sym->type & N_EXT) == 0) {
1026 fwriteint32_t(sym->strx, ofile); /* string table entry number */
1027 fwrite(&sym->type, 1, 1, ofile); /* symbol type */
1028 fwrite(&sym->sect, 1, 1, ofile); /* section */
1029 fwriteint16_t(sym->desc, ofile); /* description */
1031 /* Fix up the symbol value now that we know the final section
1032 sizes. */
1033 if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
1034 for (s = sects, fi = 1; s != NULL; s = s->next, fi++) {
1035 if (fi == sym->sect) {
1036 sym->value += s->addr;
1037 break;
1042 fwriteint32_t(sym->value, ofile); /* value (i.e. offset) */
1046 for (i = 0; i < nextdefsym; i++) {
1047 sym = extdefsyms[i];
1048 fwriteint32_t(sym->strx, ofile);
1049 fwrite(&sym->type, 1, 1, ofile); /* symbol type */
1050 fwrite(&sym->sect, 1, 1, ofile); /* section */
1051 fwriteint16_t(sym->desc, ofile); /* description */
1053 /* Fix up the symbol value now that we know the final section
1054 sizes. */
1055 if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
1056 for (s = sects, fi = 1;
1057 s != NULL && fi < sym->sect; s = s->next, ++fi)
1058 sym->value += s->size;
1061 fwriteint32_t(sym->value, ofile); /* value (i.e. offset) */
1064 for (i = 0; i < nundefsym; i++) {
1065 sym = undefsyms[i];
1066 fwriteint32_t(sym->strx, ofile);
1067 fwrite(&sym->type, 1, 1, ofile); /* symbol type */
1068 fwrite(&sym->sect, 1, 1, ofile); /* section */
1069 fwriteint16_t(sym->desc, ofile); /* description */
1071 /* Fix up the symbol value now that we know the final section
1072 sizes. */
1073 if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
1074 for (s = sects, fi = 1;
1075 s != NULL && fi < sym->sect; s = s->next, ++fi)
1076 sym->value += s->size;
1079 fwriteint32_t(sym->value, ofile); /* value (i.e. offset) */
1083 /* Fixup the snum in the relocation entries, we should be
1084 doing this only for externally undefined symbols. */
1085 static void macho_fixup_relocs (struct reloc *r)
1087 struct symbol *sym;
1088 uint32_t i;
1090 while (r != NULL) {
1091 if (r->ext) {
1092 for (i = 0; i < nundefsym; i++) {
1093 sym = undefsyms[i];
1094 if (sym->initial_snum == r->snum) {
1095 r->snum = sym->snum;
1096 break;
1100 r = r->next;
1104 /* Write out the object file. */
1106 static void macho_write (void)
1108 uint32_t offset = 0;
1110 /* mach-o object file structure:
1112 ** mach header
1113 ** uint32_t magic
1114 ** int cpu type
1115 ** int cpu subtype
1116 ** uint32_t mach file type
1117 ** uint32_t number of load commands
1118 ** uint32_t size of all load commands
1119 ** (includes section struct size of segment command)
1120 ** uint32_t flags
1122 ** segment command
1123 ** uint32_t command type == LC_SEGMENT
1124 ** uint32_t size of load command
1125 ** (including section load commands)
1126 ** char[16] segment name
1127 ** uint32_t in-memory offset
1128 ** uint32_t in-memory size
1129 ** uint32_t in-file offset to data area
1130 ** uint32_t in-file size
1131 ** (in-memory size excluding zerofill sections)
1132 ** int maximum vm protection
1133 ** int initial vm protection
1134 ** uint32_t number of sections
1135 ** uint32_t flags
1137 ** section commands
1138 ** char[16] section name
1139 ** char[16] segment name
1140 ** uint32_t in-memory offset
1141 ** uint32_t in-memory size
1142 ** uint32_t in-file offset
1143 ** uint32_t alignment
1144 ** (irrelevant in MH_OBJECT)
1145 ** uint32_t in-file offset of relocation entires
1146 ** uint32_t number of relocations
1147 ** uint32_t flags
1148 ** uint32_t reserved
1149 ** uint32_t reserved
1151 ** symbol table command
1152 ** uint32_t command type == LC_SYMTAB
1153 ** uint32_t size of load command
1154 ** uint32_t symbol table offset
1155 ** uint32_t number of symbol table entries
1156 ** uint32_t string table offset
1157 ** uint32_t string table size
1159 ** raw section data
1161 ** padding to int32_t boundary
1163 ** relocation data (struct reloc)
1164 ** int32_t offset
1165 ** uint data (symbolnum, pcrel, length, extern, type)
1167 ** symbol table data (struct nlist)
1168 ** int32_t string table entry number
1169 ** uint8_t type
1170 ** (extern, absolute, defined in section)
1171 ** uint8_t section
1172 ** (0 for global symbols, section number of definition (>= 1, <=
1173 ** 254) for local symbols, size of variable for common symbols
1174 ** [type == extern])
1175 ** int16_t description
1176 ** (for stab debugging format)
1177 ** uint32_t value (i.e. file offset) of symbol or stab offset
1179 ** string table data
1180 ** list of null-terminated strings
1183 /* Emit the Mach-O header. */
1184 macho_write_header();
1186 offset = MACHO_HEADER_SIZE + head_sizeofcmds;
1188 /* emit the segment load command */
1189 if (seg_nsects > 0)
1190 offset = macho_write_segment (offset);
1191 else
1192 nasm_error(ERR_WARNING, "no sections?");
1194 if (nsyms > 0) {
1195 /* write out symbol command */
1196 fwriteint32_t(LC_SYMTAB, ofile); /* cmd == LC_SYMTAB */
1197 fwriteint32_t(MACHO_SYMCMD_SIZE, ofile); /* size of load command */
1198 fwriteint32_t(offset, ofile); /* symbol table offset */
1199 fwriteint32_t(nsyms, ofile); /* number of symbol
1200 ** table entries */
1202 offset += nsyms * MACHO_NLIST_SIZE;
1203 fwriteint32_t(offset, ofile); /* string table offset */
1204 fwriteint32_t(strslen, ofile); /* string table size */
1207 /* emit section data */
1208 if (seg_nsects > 0)
1209 macho_write_section ();
1211 /* emit symbol table if we have symbols */
1212 if (nsyms > 0)
1213 macho_write_symtab ();
1215 /* we don't need to pad here since MACHO_NLIST_SIZE == 12 */
1217 /* emit string table */
1218 saa_fpwrite(strs, ofile);
1220 /* We do quite a bit here, starting with finalizing all of the data
1221 for the object file, writing, and then freeing all of the data from
1222 the file. */
1224 static void macho_cleanup(int debuginfo)
1226 struct section *s;
1227 struct reloc *r;
1228 struct symbol *sym;
1230 (void)debuginfo;
1232 /* Sort all symbols. */
1233 macho_layout_symbols (&nsyms, &strslen);
1235 /* Fixup relocation entries */
1236 for (s = sects; s != NULL; s = s->next) {
1237 macho_fixup_relocs (s->relocs);
1240 /* First calculate and finalize needed values. */
1241 macho_calculate_sizes();
1242 macho_write();
1244 /* free up everything */
1245 while (sects->next) {
1246 s = sects;
1247 sects = sects->next;
1249 saa_free(s->data);
1250 while (s->relocs != NULL) {
1251 r = s->relocs;
1252 s->relocs = s->relocs->next;
1253 nasm_free(r);
1256 nasm_free(s);
1259 saa_free(strs);
1260 raa_free(extsyms);
1262 if (syms) {
1263 while (syms->next) {
1264 sym = syms;
1265 syms = syms->next;
1267 nasm_free (sym);
1272 /* Debugging routines. */
1273 static void debug_reloc (struct reloc *r)
1275 fprintf (stdout, "reloc:\n");
1276 fprintf (stdout, "\taddr: %"PRId32"\n", r->addr);
1277 fprintf (stdout, "\tsnum: %d\n", r->snum);
1278 fprintf (stdout, "\tpcrel: %d\n", r->pcrel);
1279 fprintf (stdout, "\tlength: %d\n", r->length);
1280 fprintf (stdout, "\text: %d\n", r->ext);
1281 fprintf (stdout, "\ttype: %d\n", r->type);
1284 static void debug_section_relocs (struct section *s)
1286 struct reloc *r = s->relocs;
1288 fprintf (stdout, "relocs for section %s:\n\n", s->sectname);
1290 while (r != NULL) {
1291 debug_reloc (r);
1292 r = r->next;
1296 struct ofmt of_macho32 = {
1297 "NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X (i386) object files",
1298 "macho32",
1300 null_debug_arr,
1301 &null_debug_form,
1302 macho_stdmac,
1303 macho_init,
1304 null_setinfo,
1305 macho_output,
1306 macho_symdef,
1307 macho_section,
1308 macho_sectalign,
1309 macho_segbase,
1310 null_directive,
1311 macho_filename,
1312 macho_cleanup
1315 #endif
1318 * Local Variables:
1319 * mode:c
1320 * c-basic-offset:4
1321 * End:
1323 * end of file */