1 /* ----------------------------------------------------------------------- *
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
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. */
54 #include "output/outform.h"
55 #include "output/outlib.h"
57 #if defined(OF_MACHO32)
59 /* Mach-O in-file header structure sizes */
60 #define MACHO_HEADER_SIZE (28)
61 #define MACHO_SEGCMD_SIZE (56)
62 #define MACHO_SECTCMD_SIZE (68)
63 #define MACHO_SYMCMD_SIZE (24)
64 #define MACHO_NLIST_SIZE (12)
65 #define MACHO_RELINFO_SIZE (8)
67 /* Mach-O file header values */
68 #define MH_MAGIC (0xfeedface)
69 #define CPU_TYPE_I386 (7) /* x86 platform */
70 #define CPU_SUBTYPE_I386_ALL (3) /* all-x86 compatible */
71 #define MH_OBJECT (0x1) /* object file */
73 #define LC_SEGMENT (0x1) /* 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)
85 /* nasm internal data */
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 uint32_t addr; /* in-memory address (subject to alignment) */
96 uint32_t size; /* in-memory and -file size */
97 uint32_t nreloc; /* relocation entry count */
98 uint32_t flags; /* type and attributes (masked) */
101 #define SECTION_TYPE 0x000000ff /* section type mask */
103 #define S_REGULAR (0x0) /* standard section */
104 #define S_ZEROFILL (0x1) /* zerofill, in-memory only */
106 #define SECTION_ATTRIBUTES_SYS 0x00ffff00 /* system setable attributes */
107 #define S_ATTR_SOME_INSTRUCTIONS 0x00000400 /* section contains some
108 machine instructions */
109 #define S_ATTR_EXT_RELOC 0x00000200 /* section has external
110 relocation entries */
111 #define S_ATTR_LOC_RELOC 0x00000100 /* section has local
112 relocation entries */
115 static struct sectmap {
116 const char *nasmsect;
118 const char *sectname;
121 {".text", "__TEXT", "__text", S_REGULAR|S_ATTR_SOME_INSTRUCTIONS},
122 {".data", "__DATA", "__data", S_REGULAR},
123 {".rodata", "__DATA", "__const", S_REGULAR},
124 {".bss", "__DATA", "__bss", S_ZEROFILL},
125 {NULL, NULL, NULL, 0}
129 /* nasm internal data */
132 /* data that goes into the file */
133 int32_t addr; /* op's offset in section */
134 unsigned int snum:24, /* contains symbol index if
135 ** ext otherwise in-file
137 pcrel:1, /* relative relocation */
138 length:2, /* 0=byte, 1=word, 2=int32_t */
139 ext:1, /* external symbol referenced */
140 type:4; /* reloc type, 0 for us */
143 #define R_ABS 0 /* absolute relocation */
144 #define R_SCATTERED 0x80000000 /* reloc entry is scattered if
145 ** highest bit == 1 */
148 /* nasm internal data */
149 struct symbol *next; /* next symbol in the list */
150 char *name; /* name of this symbol */
151 int32_t initial_snum; /* symbol number used above in
153 int32_t snum; /* true snum for reloc */
155 /* data that goes into the file */
156 int32_t strx; /* string table index */
157 uint8_t type; /* symbol type */
158 uint8_t sect; /* NO_SECT or section number */
159 int16_t desc; /* for stab debugging, 0 for us */
160 uint32_t value; /* offset of symbol in section */
163 /* symbol type bits */
164 #define N_EXT 0x01 /* global or external symbol */
166 #define N_UNDF 0x0 /* undefined symbol | n_sect == */
167 #define N_ABS 0x2 /* absolute symbol | NO_SECT */
168 #define N_SECT 0xe /* defined symbol, n_sect holds
171 #define N_TYPE 0x0e /* type bit mask */
173 #define DEFAULT_SECTION_ALIGNMENT 0 /* byte (i.e. no) alignment */
175 /* special section number values */
176 #define NO_SECT 0 /* no section, invalid */
177 #define MAX_SECT 255 /* maximum number of sections */
179 static struct section *sects, **sectstail;
180 static struct symbol *syms, **symstail;
181 static uint32_t nsyms;
183 /* These variables are set by macho_layout_symbols() to organize
184 the symbol table and string table in order the dynamic linker
185 expects. They are then used in macho_write() to put out the
186 symbols and strings in that order.
188 The order of the symbol table is:
190 defined external symbols (sorted by name)
191 undefined external symbols (sorted by name)
193 The order of the string table is:
194 strings for external symbols
195 strings for local symbols
197 static uint32_t ilocalsym = 0;
198 static uint32_t iextdefsym = 0;
199 static uint32_t iundefsym = 0;
200 static uint32_t nlocalsym;
201 static uint32_t nextdefsym;
202 static uint32_t nundefsym;
203 static struct symbol **extdefsyms = NULL;
204 static struct symbol **undefsyms = NULL;
206 static struct RAA *extsyms;
207 static struct SAA *strs;
208 static uint32_t strslen;
210 static FILE *machofp;
212 static evalfunc evaluate;
214 extern struct ofmt of_macho;
216 /* Global file information. This should be cleaned up into either
217 a structure or as function arguments. */
218 uint32_t head_ncmds = 0;
219 uint32_t head_sizeofcmds = 0;
220 uint32_t seg_filesize = 0;
221 uint32_t seg_vmsize = 0;
222 uint32_t seg_nsects = 0;
223 uint32_t rel_padcnt = 0;
226 #define xstrncpy(xdst, xsrc) \
227 memset(xdst, '\0', sizeof(xdst)); /* zero out whole buffer */ \
228 strncpy(xdst, xsrc, sizeof(xdst)); /* copy over string */ \
229 xdst[sizeof(xdst) - 1] = '\0'; /* proper null-termination */
231 #define align(x, y) \
232 (((x) + (y) - 1) & ~((y) - 1)) /* align x to multiple of y */
234 #define alignint32_t(x) \
235 align(x, sizeof(int32_t)) /* align x to int32_t boundary */
237 static void debug_reloc (struct reloc *);
238 static void debug_section_relocs (struct section *) _unused;
240 static int exact_log2 (uint32_t align)
244 } else if (align & (align-1)) {
245 return -1; /* Not a power of 2 */
248 return __builtin_ctzl (align);
252 /* We know exactly one bit is set at this point. */
253 if (align & 0xffff0000)
255 if (align & 0xff00ff00)
257 if (align & 0xf0f0f0f0)
259 if (align & 0xcccccccc)
261 if (align & 0xaaaaaaaa)
269 static struct section *get_section_by_name(const char *segname,
270 const char *sectname)
274 for (s = sects; s != NULL; s = s->next)
275 if (!strcmp(s->segname, segname) && !strcmp(s->sectname, sectname))
281 static struct section *get_section_by_index(const int32_t index)
285 for (s = sects; s != NULL; s = s->next)
286 if (index == s->index)
292 static int32_t get_section_index_by_name(const char *segname,
293 const char *sectname)
297 for (s = sects; s != NULL; s = s->next)
298 if (!strcmp(s->segname, segname) && !strcmp(s->sectname, sectname))
304 static char *get_section_name_by_index(const int32_t index)
308 for (s = sects; s != NULL; s = s->next)
309 if (index == s->index)
315 static uint8_t get_section_fileindex_by_index(const int32_t index)
320 for (s = sects; s != NULL && i < MAX_SECT; s = s->next, ++i)
321 if (index == s->index)
326 "too many sections (>255) - clipped by fileindex");
331 static void macho_init(FILE * fp, efunc errfunc, ldfunc ldef,
340 (void)ldef; /* placate optimisers */
352 extsyms = raa_init();
355 /* string table starts with a zero byte - don't ask why */
356 saa_wbytes(strs, &zero, sizeof(char));
360 static void sect_write(struct section *sect,
361 const uint8_t *data, uint32_t len)
363 saa_wbytes(sect->data, data, len);
367 static void add_reloc(struct section *sect, int32_t section,
368 int pcrel, int bytes)
373 /* NeXT as puts relocs in reversed order (address-wise) into the
374 ** files, so we do the same, doesn't seem to make much of a
375 ** difference either way */
376 r = nasm_malloc(sizeof(struct reloc));
377 r->next = sect->relocs;
380 /* the current end of the section will be the symbol's address for
381 ** now, might have to be fixed by macho_fixup_relocs() later on. make
382 ** sure we don't make the symbol scattered by setting the highest
383 ** bit by accident */
384 r->addr = sect->size & ~R_SCATTERED;
388 /* match byte count 1, 2, 4 to length codes 0, 1, 2 respectively */
389 r->length = bytes >> 1;
391 /* vanilla relocation (GENERIC_RELOC_VANILLA) */
394 if (section == NO_SEG) {
395 /* absolute local symbol if no section index given */
398 fi = get_section_fileindex_by_index(section);
401 /* external symbol if no section with that index known,
402 ** symbol number was saved in macho_symdef() */
403 r->snum = raa_read(extsyms, section);
406 /* local symbol in section fi */
414 static void macho_output(int32_t secto, const void *data,
415 enum out_type type, uint64_t size,
416 int32_t section, int32_t wrt)
418 struct section *s, *sbss;
420 uint8_t mydata[4], *p;
424 error(ERR_NONFATAL, "WRT not supported by Mach-O output format");
425 /* continue to do _something_ */
428 if (secto == NO_SEG) {
429 if (type != OUT_RESERVE)
430 error(ERR_NONFATAL, "attempt to assemble code in "
436 s = get_section_by_index(secto);
439 error(ERR_WARNING, "attempt to assemble code in"
440 " section %d: defaulting to `.text'", secto);
441 s = get_section_by_name("__TEXT", "__text");
443 /* should never happen */
445 error(ERR_PANIC, "text section not found");
448 sbss = get_section_by_name("__DATA", "__bss");
450 if (s == sbss && type != OUT_RESERVE) {
451 error(ERR_WARNING, "attempt to initialize memory in the"
452 " BSS section: ignored");
453 s->size += realsize(type, size);
460 error(ERR_WARNING, "uninitialized space declared in"
461 " %s section: zeroing",
462 get_section_name_by_index(secto));
464 sect_write(s, NULL, size);
471 if (section != NO_SEG)
472 error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
474 sect_write(s, data, size);
478 addr = *(int64_t *)data;
480 if (section != NO_SEG) {
482 error(ERR_NONFATAL, "Mach-O format does not support"
483 " section base references");
485 add_reloc(s, section, 0, size);
489 WRITEADDR(p, addr, size);
490 sect_write(s, mydata, size);
494 if (section == secto)
495 error(ERR_PANIC, "intra-section OUT_REL2ADR");
497 if (section != NO_SEG && section % 2) {
498 error(ERR_NONFATAL, "Mach-O format does not support"
499 " section base references");
501 add_reloc(s, section, 1, 2);
504 WRITESHORT(p, *(int32_t *)data - (size + s->size));
505 sect_write(s, mydata, 2L);
509 if (section == secto)
510 error(ERR_PANIC, "intra-section OUT_REL4ADR");
512 if (section != NO_SEG && section % 2) {
513 error(ERR_NONFATAL, "Mach-O format does not support"
514 " section base references");
516 add_reloc(s, section, 1, 4);
519 WRITELONG(p, *(int32_t *)data - (size + s->size));
520 sect_write(s, mydata, 4L);
524 error(ERR_PANIC, "unknown output type?");
529 static int32_t macho_section(char *name, int pass, int *bits)
531 int32_t index, originalIndex;
532 char *sectionAttributes;
538 /* Default to 32 bits. */
542 sectionAttributes = NULL;
544 sectionAttributes = name;
545 name = nasm_strsep(§ionAttributes, " \t");
548 for (sm = sectmap; sm->nasmsect != NULL; ++sm) {
549 /* make lookup into section name translation table */
550 if (!strcmp(name, sm->nasmsect)) {
551 char *currentAttribute;
553 /* try to find section with that name */
554 originalIndex = index = get_section_index_by_name(sm->segname,
557 /* create it if it doesn't exist yet */
559 s = *sectstail = nasm_malloc(sizeof(struct section));
561 sectstail = &s->next;
563 s->data = saa_init(1L);
564 s->index = seg_alloc();
568 xstrncpy(s->segname, sm->segname);
569 xstrncpy(s->sectname, sm->sectname);
572 s->flags = sm->flags;
576 s = get_section_by_index(index);
579 while ((NULL != sectionAttributes)
580 && (currentAttribute = nasm_strsep(§ionAttributes, " \t"))) {
581 if (0 != *currentAttribute) {
582 if (!nasm_strnicmp("align=", currentAttribute, 6)) {
584 int newAlignment, value;
586 value = strtoul(currentAttribute + 6, (char**)&end, 0);
587 newAlignment = exact_log2(value);
591 "unknown or missing alignment value \"%s\" "
592 "specified for section \"%s\"",
593 currentAttribute + 6,
596 } else if (0 > newAlignment) {
598 "alignment of %d (for section \"%s\") is not "
605 if ((-1 != originalIndex)
606 && (s->align != newAlignment)
607 && (s->align != -1)) {
609 "section \"%s\" has already been specified "
610 "with alignment %d, conflicts with new "
618 s->align = newAlignment;
619 } else if (!nasm_stricmp("data", currentAttribute)) {
620 /* Do nothing; 'data' is implicit */
623 "unknown section attribute %s for section %s",
635 error(ERR_PANIC, "invalid section name %s", name);
639 static void macho_symdef(char *name, int32_t section, int64_t offset,
640 int is_global, char *special)
645 error(ERR_NONFATAL, "The Mach-O output format does "
646 "not support any special symbol types");
650 if (is_global == 3) {
651 error(ERR_NONFATAL, "The Mach-O format does not "
652 "(yet) support forward reference fixups.");
656 sym = *symstail = nasm_malloc(sizeof(struct symbol));
658 symstail = &sym->next;
665 sym->initial_snum = -1;
667 /* external and common symbols get N_EXT */
671 if (section == NO_SEG) {
672 /* symbols in no section get absolute */
678 /* get the in-file index of the section the symbol was defined in */
679 sym->sect = get_section_fileindex_by_index(section);
681 if (sym->sect == NO_SECT) {
682 /* remember symbol number of references to external
683 ** symbols, this works because every external symbol gets
684 ** its own section number allocated internally by nasm and
685 ** can so be used as a key */
686 extsyms = raa_write(extsyms, section, nsyms);
687 sym->initial_snum = nsyms;
692 /* there isn't actually a difference between global
693 ** and common symbols, both even have their size in
699 /* give an error on unfound section if it's not an
700 ** external or common symbol (assemble_file() does a
701 ** seg_alloc() on every call for them) */
702 error(ERR_PANIC, "in-file index for section %d not found",
711 static int32_t macho_segbase(int32_t section)
716 static void macho_filename(char *inname, char *outname, efunc error)
718 standard_extension(inname, outname, ".o", error);
721 extern macros_t macho_stdmac[];
723 /* Comparison function for qsort symbol layout. */
724 static int layout_compare (const struct symbol **s1,
725 const struct symbol **s2)
727 return (strcmp ((*s1)->name, (*s2)->name));
730 /* The native assembler does a few things in a similar function
732 * Remove temporary labels
733 * Sort symbols according to local, external, undefined (by name)
734 * Order the string table
736 We do not remove temporary labels right now.
738 numsyms is the total number of symbols we have. strtabsize is the
739 number entries in the string table. */
741 static void macho_layout_symbols (uint32_t *numsyms,
742 uint32_t *strtabsize)
744 struct symbol *sym, **symp;
748 *strtabsize = sizeof (char);
752 while ((sym = *symp)) {
753 /* Undefined symbols are now external. */
754 if (sym->type == N_UNDF)
757 if ((sym->type & N_EXT) == 0) {
758 sym->snum = *numsyms;
759 *numsyms = *numsyms + 1;
763 if ((sym->type & N_TYPE) != N_UNDF)
768 /* If we handle debug info we'll want
769 to check for it here instead of just
770 adding the symbol to the string table. */
771 sym->strx = *strtabsize;
772 saa_wbytes (strs, sym->name, (int32_t)(strlen(sym->name) + 1));
773 *strtabsize += strlen(sym->name) + 1;
778 /* Next, sort the symbols. Most of this code is a direct translation from
779 the Apple cctools symbol layout. We need to keep compatibility with that. */
780 /* Set the indexes for symbol groups into the symbol table */
782 iextdefsym = nlocalsym;
783 iundefsym = nlocalsym + nextdefsym;
785 /* allocate arrays for sorting externals by name */
786 extdefsyms = nasm_malloc(nextdefsym * sizeof(struct symbol *));
787 undefsyms = nasm_malloc(nundefsym * sizeof(struct symbol *));
794 while ((sym = *symp)) {
796 if((sym->type & N_EXT) == 0) {
797 sym->strx = *strtabsize;
798 saa_wbytes (strs, sym->name, (int32_t)(strlen (sym->name) + 1));
799 *strtabsize += strlen(sym->name) + 1;
802 if((sym->type & N_TYPE) != N_UNDF)
803 extdefsyms[i++] = sym;
805 undefsyms[j++] = sym;
810 qsort(extdefsyms, nextdefsym, sizeof(struct symbol *),
811 (int (*)(const void *, const void *))layout_compare);
812 qsort(undefsyms, nundefsym, sizeof(struct symbol *),
813 (int (*)(const void *, const void *))layout_compare);
815 for(i = 0; i < nextdefsym; i++) {
816 extdefsyms[i]->snum = *numsyms;
819 for(j = 0; j < nundefsym; j++) {
820 undefsyms[j]->snum = *numsyms;
825 /* Calculate some values we'll need for writing later. */
827 static void macho_calculate_sizes (void)
831 /* count sections and calculate in-memory and in-file offsets */
832 for (s = sects; s != NULL; s = s->next) {
835 /* zerofill sections aren't actually written to the file */
836 if ((s->flags & SECTION_TYPE) != S_ZEROFILL)
837 seg_filesize += s->size;
839 /* recalculate segment address based on alignment and vm size */
840 s->addr = seg_vmsize;
841 /* we need section alignment to calculate final section address */
843 s->align = DEFAULT_SECTION_ALIGNMENT;
845 uint32_t newaddr = align(s->addr, 1 << s->align);
846 pad = newaddr - s->addr;
850 seg_vmsize += s->size + pad;
854 /* calculate size of all headers, load commands and sections to
855 ** get a pointer to the start of all the raw data */
856 if (seg_nsects > 0) {
859 MACHO_SEGCMD_SIZE + seg_nsects * MACHO_SECTCMD_SIZE;
864 head_sizeofcmds += MACHO_SYMCMD_SIZE;
868 /* Write out the header information for the file. */
870 static void macho_write_header (void)
872 fwriteint32_t(MH_MAGIC, machofp); /* magic */
873 fwriteint32_t(CPU_TYPE_I386, machofp); /* CPU type */
874 fwriteint32_t(CPU_SUBTYPE_I386_ALL, machofp); /* CPU subtype */
875 fwriteint32_t(MH_OBJECT, machofp); /* Mach-O file type */
876 fwriteint32_t(head_ncmds, machofp); /* number of load commands */
877 fwriteint32_t(head_sizeofcmds, machofp); /* size of load commands */
878 fwriteint32_t(0, machofp); /* no flags */
881 /* Write out the segment load command at offset. */
883 static uint32_t macho_write_segment (uint32_t offset)
885 uint32_t rel_base = alignint32_t (offset + seg_filesize);
886 uint32_t s_reloff = 0;
889 fwriteint32_t(LC_SEGMENT, machofp); /* cmd == LC_SEGMENT */
891 /* size of load command including section load commands */
892 fwriteint32_t(MACHO_SEGCMD_SIZE + seg_nsects *
893 MACHO_SECTCMD_SIZE, machofp);
895 /* in an MH_OBJECT file all sections are in one unnamed (name
896 ** all zeros) segment */
897 fwritezero(16, machofp);
898 fwriteint32_t(0, machofp); /* in-memory offset */
899 fwriteint32_t(seg_vmsize, machofp); /* in-memory size */
900 fwriteint32_t(offset, machofp); /* in-file offset to data */
901 fwriteint32_t(seg_filesize, machofp); /* in-file size */
902 fwriteint32_t(VM_PROT_DEFAULT, machofp); /* maximum vm protection */
903 fwriteint32_t(VM_PROT_DEFAULT, machofp); /* initial vm protection */
904 fwriteint32_t(seg_nsects, machofp); /* number of sections */
905 fwriteint32_t(0, machofp); /* no flags */
907 /* emit section headers */
908 for (s = sects; s != NULL; s = s->next) {
909 fwrite(s->sectname, sizeof(s->sectname), 1, machofp);
910 fwrite(s->segname, sizeof(s->segname), 1, machofp);
911 fwriteint32_t(s->addr, machofp);
912 fwriteint32_t(s->size, machofp);
914 /* dummy data for zerofill sections or proper values */
915 if ((s->flags & SECTION_TYPE) != S_ZEROFILL) {
916 fwriteint32_t(offset, machofp);
917 /* Write out section alignment, as a power of two.
918 e.g. 32-bit word alignment would be 2 (2^^2 = 4). */
920 s->align = DEFAULT_SECTION_ALIGNMENT;
921 fwriteint32_t(s->align, machofp);
922 /* To be compatible with cctools as we emit
923 a zero reloff if we have no relocations. */
924 fwriteint32_t(s->nreloc ? rel_base + s_reloff : 0, machofp);
925 fwriteint32_t(s->nreloc, machofp);
928 s_reloff += s->nreloc * MACHO_RELINFO_SIZE;
930 fwriteint32_t(0, machofp);
931 fwriteint32_t(0, machofp);
932 fwriteint32_t(0, machofp);
933 fwriteint32_t(0, machofp);
936 fwriteint32_t(s->flags, machofp); /* flags */
937 fwriteint32_t(0, machofp); /* reserved */
938 fwriteint32_t(0, machofp); /* reserved */
941 rel_padcnt = rel_base - offset;
942 offset = rel_base + s_reloff;
947 /* For a given chain of relocs r, write out the entire relocation
948 chain to the object file. */
950 static void macho_write_relocs (struct reloc *r)
955 fwriteint32_t(r->addr, machofp); /* reloc offset */
958 word2 |= r->pcrel << 24;
959 word2 |= r->length << 25;
960 word2 |= r->ext << 27;
961 word2 |= r->type << 28;
962 fwriteint32_t(word2, machofp); /* reloc data */
968 /* Write out the section data. */
969 static void macho_write_section (void)
971 struct section *s, *s2;
973 uint8_t fi, *p, *q, blk[4];
976 for (s = sects; s != NULL; s = s->next) {
977 if ((s->flags & SECTION_TYPE) == S_ZEROFILL)
980 /* no padding needs to be done to the sections */
982 /* Like a.out Mach-O references things in the data or bss
983 * sections by addresses which are actually relative to the
984 * start of the _text_ section, in the _file_. See outaout.c
985 * for more information. */
987 for (r = s->relocs; r != NULL; r = r->next) {
988 saa_fread(s->data, r->addr, blk, (int32_t)r->length << 1);
992 /* get offset based on relocation type */
994 l += ((int32_t)*p++) << 8;
996 if (r->length == 2) {
997 l += ((int32_t)*p++) << 16;
998 l += ((int32_t)*p++) << 24;
1002 /* If the relocation is internal add to the current section
1003 offset. Otherwise the only value we need is the symbol
1004 offset which we already have. The linker takes care
1005 of the rest of the address. */
1007 /* generate final address by section address and offset */
1008 for (s2 = sects, fi = 1;
1009 s2 != NULL; s2 = s2->next, fi++) {
1010 if (fi == r->snum) {
1017 /* write new offset back */
1020 else if (r->length == 1)
1025 saa_fwrite(s->data, r->addr, blk, (int32_t)r->length << 1);
1028 /* dump the section data to file */
1029 saa_fpwrite(s->data, machofp);
1032 /* pad last section up to reloc entries on int32_t boundary */
1033 fwritezero(rel_padcnt, machofp);
1035 /* emit relocation entries */
1036 for (s = sects; s != NULL; s = s->next)
1037 macho_write_relocs (s->relocs);
1040 /* Write out the symbol table. We should already have sorted this
1042 static void macho_write_symtab (void)
1049 /* we don't need to pad here since MACHO_RELINFO_SIZE == 8 */
1051 for (sym = syms; sym != NULL; sym = sym->next) {
1052 if ((sym->type & N_EXT) == 0) {
1053 fwriteint32_t(sym->strx, machofp); /* string table entry number */
1054 fwrite(&sym->type, 1, 1, machofp); /* symbol type */
1055 fwrite(&sym->sect, 1, 1, machofp); /* section */
1056 fwriteint16_t(sym->desc, machofp); /* description */
1058 /* Fix up the symbol value now that we know the final section
1060 if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
1061 for (s = sects, fi = 1;
1062 s != NULL && fi < sym->sect; s = s->next, ++fi)
1063 sym->value += s->size;
1066 fwriteint32_t(sym->value, machofp); /* value (i.e. offset) */
1070 for (i = 0; i < nextdefsym; i++) {
1071 sym = extdefsyms[i];
1072 fwriteint32_t(sym->strx, machofp);
1073 fwrite(&sym->type, 1, 1, machofp); /* symbol type */
1074 fwrite(&sym->sect, 1, 1, machofp); /* section */
1075 fwriteint16_t(sym->desc, machofp); /* description */
1077 /* Fix up the symbol value now that we know the final section
1079 if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
1080 for (s = sects, fi = 1;
1081 s != NULL && fi < sym->sect; s = s->next, ++fi)
1082 sym->value += s->size;
1085 fwriteint32_t(sym->value, machofp); /* value (i.e. offset) */
1088 for (i = 0; i < nundefsym; i++) {
1090 fwriteint32_t(sym->strx, machofp);
1091 fwrite(&sym->type, 1, 1, machofp); /* symbol type */
1092 fwrite(&sym->sect, 1, 1, machofp); /* section */
1093 fwriteint16_t(sym->desc, machofp); /* description */
1095 /* Fix up the symbol value now that we know the final section
1097 if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
1098 for (s = sects, fi = 1;
1099 s != NULL && fi < sym->sect; s = s->next, ++fi)
1100 sym->value += s->size;
1103 fwriteint32_t(sym->value, machofp); /* value (i.e. offset) */
1107 /* Fixup the snum in the relocation entries, we should be
1108 doing this only for externally undefined symbols. */
1109 static void macho_fixup_relocs (struct reloc *r)
1116 for (i = 0; i < nundefsym; i++) {
1118 if (sym->initial_snum == r->snum) {
1119 r->snum = sym->snum;
1128 /* Write out the object file. */
1130 static void macho_write (void)
1132 uint32_t offset = 0;
1134 /* mach-o object file structure:
1140 ** uint32_t mach file type
1141 ** uint32_t number of load commands
1142 ** uint32_t size of all load commands
1143 ** (includes section struct size of segment command)
1147 ** uint32_t command type == LC_SEGMENT
1148 ** uint32_t size of load command
1149 ** (including section load commands)
1150 ** char[16] segment name
1151 ** uint32_t in-memory offset
1152 ** uint32_t in-memory size
1153 ** uint32_t in-file offset to data area
1154 ** uint32_t in-file size
1155 ** (in-memory size excluding zerofill sections)
1156 ** int maximum vm protection
1157 ** int initial vm protection
1158 ** uint32_t number of sections
1162 ** char[16] section name
1163 ** char[16] segment name
1164 ** uint32_t in-memory offset
1165 ** uint32_t in-memory size
1166 ** uint32_t in-file offset
1167 ** uint32_t alignment
1168 ** (irrelevant in MH_OBJECT)
1169 ** uint32_t in-file offset of relocation entires
1170 ** uint32_t number of relocations
1172 ** uint32_t reserved
1173 ** uint32_t reserved
1175 ** symbol table command
1176 ** uint32_t command type == LC_SYMTAB
1177 ** uint32_t size of load command
1178 ** uint32_t symbol table offset
1179 ** uint32_t number of symbol table entries
1180 ** uint32_t string table offset
1181 ** uint32_t string table size
1185 ** padding to int32_t boundary
1187 ** relocation data (struct reloc)
1189 ** uint data (symbolnum, pcrel, length, extern, type)
1191 ** symbol table data (struct nlist)
1192 ** int32_t string table entry number
1194 ** (extern, absolute, defined in section)
1196 ** (0 for global symbols, section number of definition (>= 1, <=
1197 ** 254) for local symbols, size of variable for common symbols
1198 ** [type == extern])
1199 ** int16_t description
1200 ** (for stab debugging format)
1201 ** uint32_t value (i.e. file offset) of symbol or stab offset
1203 ** string table data
1204 ** list of null-terminated strings
1207 /* Emit the Mach-O header. */
1208 macho_write_header();
1210 offset = MACHO_HEADER_SIZE + head_sizeofcmds;
1212 /* emit the segment load command */
1214 offset = macho_write_segment (offset);
1216 error(ERR_WARNING, "no sections?");
1219 /* write out symbol command */
1220 fwriteint32_t(LC_SYMTAB, machofp); /* cmd == LC_SYMTAB */
1221 fwriteint32_t(MACHO_SYMCMD_SIZE, machofp); /* size of load command */
1222 fwriteint32_t(offset, machofp); /* symbol table offset */
1223 fwriteint32_t(nsyms, machofp); /* number of symbol
1226 offset += nsyms * MACHO_NLIST_SIZE;
1227 fwriteint32_t(offset, machofp); /* string table offset */
1228 fwriteint32_t(strslen, machofp); /* string table size */
1231 /* emit section data */
1233 macho_write_section ();
1235 /* emit symbol table if we have symbols */
1237 macho_write_symtab ();
1239 /* we don't need to pad here since MACHO_NLIST_SIZE == 12 */
1241 /* emit string table */
1242 saa_fpwrite(strs, machofp);
1244 /* We do quite a bit here, starting with finalizing all of the data
1245 for the object file, writing, and then freeing all of the data from
1248 static void macho_cleanup(int debuginfo)
1256 /* Sort all symbols. */
1257 macho_layout_symbols (&nsyms, &strslen);
1259 /* Fixup relocation entries */
1260 for (s = sects; s != NULL; s = s->next) {
1261 macho_fixup_relocs (s->relocs);
1264 /* First calculate and finalize needed values. */
1265 macho_calculate_sizes();
1268 /* free up everything */
1269 while (sects->next) {
1271 sects = sects->next;
1274 while (s->relocs != NULL) {
1276 s->relocs = s->relocs->next;
1287 while (syms->next) {
1296 /* Debugging routines. */
1297 static void debug_reloc (struct reloc *r)
1299 fprintf (stdout, "reloc:\n");
1300 fprintf (stdout, "\taddr: %"PRId32"\n", r->addr);
1301 fprintf (stdout, "\tsnum: %d\n", r->snum);
1302 fprintf (stdout, "\tpcrel: %d\n", r->pcrel);
1303 fprintf (stdout, "\tlength: %d\n", r->length);
1304 fprintf (stdout, "\text: %d\n", r->ext);
1305 fprintf (stdout, "\ttype: %d\n", r->type);
1308 static void debug_section_relocs (struct section *s)
1310 struct reloc *r = s->relocs;
1312 fprintf (stdout, "relocs for section %s:\n\n", s->sectname);
1320 struct ofmt of_macho32 = {
1321 "NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X (i386) object files",
1338 struct ofmt of_macho = {
1339 "MACHO (short name for MACHO32)",