1 /* outmacho.c output routines for the Netwide Assembler to produce
2 * NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X object files
4 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
5 * Julian Hall. All rights reserved. The software is
6 * redistributable under the license given in the file "LICENSE"
7 * distributed in the NASM archive.
10 /* Most of this file is, like Mach-O itself, based on a.out. For more
11 * guidelines see outaout.c. */
30 /* Mach-O in-file header structure sizes */
31 #define MACHO_HEADER_SIZE (28)
32 #define MACHO_SEGCMD_SIZE (56)
33 #define MACHO_SECTCMD_SIZE (68)
34 #define MACHO_SYMCMD_SIZE (24)
35 #define MACHO_NLIST_SIZE (12)
36 #define MACHO_RELINFO_SIZE (8)
38 /* Mach-O file header values */
39 #define MH_MAGIC (0xfeedface)
40 #define CPU_TYPE_I386 (7) /* x86 platform */
41 #define CPU_SUBTYPE_I386_ALL (3) /* all-x86 compatible */
42 #define MH_OBJECT (0x1) /* object file */
44 #define LC_SEGMENT (0x1) /* segment load command */
45 #define LC_SYMTAB (0x2) /* symbol table load command */
47 #define VM_PROT_NONE (0x00)
48 #define VM_PROT_READ (0x01)
49 #define VM_PROT_WRITE (0x02)
50 #define VM_PROT_EXECUTE (0x04)
52 #define VM_PROT_DEFAULT (VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE)
53 #define VM_PROT_ALL (VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE)
56 /* nasm internal data */
63 /* data that goes into the file */
64 char sectname
[16]; /* what this section is called */
65 char segname
[16]; /* segment this section will be in */
66 uint32_t size
; /* in-memory and -file size */
67 uint32_t nreloc
; /* relocation entry count */
68 uint32_t flags
; /* type and attributes (masked) */
71 #define SECTION_TYPE 0x000000ff /* section type mask */
73 #define S_REGULAR (0x0) /* standard section */
74 #define S_ZEROFILL (0x1) /* zerofill, in-memory only */
76 #define SECTION_ATTRIBUTES_SYS 0x00ffff00 /* system setable attributes */
77 #define S_ATTR_SOME_INSTRUCTIONS 0x00000400 /* section contains some
78 machine instructions */
79 #define S_ATTR_EXT_RELOC 0x00000200 /* section has external
81 #define S_ATTR_LOC_RELOC 0x00000100 /* section has local
85 static struct sectmap
{
91 {".text", "__TEXT", "__text", S_REGULAR
|S_ATTR_SOME_INSTRUCTIONS
},
92 {".data", "__DATA", "__data", S_REGULAR
},
93 {".rodata", "__DATA", "__const", S_REGULAR
},
94 {".bss", "__DATA", "__bss", S_ZEROFILL
},
99 /* nasm internal data */
102 /* data that goes into the file */
103 int32_t addr
; /* op's offset in section */
104 unsigned int snum
:24, /* contains symbol index if
105 ** ext otherwise in-file
107 pcrel
:1, /* relative relocation */
108 length
:2, /* 0=byte, 1=word, 2=int32_t */
109 ext
:1, /* external symbol referenced */
110 type
:4; /* reloc type, 0 for us */
113 #define R_ABS 0 /* absolute relocation */
114 #define R_SCATTERED 0x80000000 /* reloc entry is scattered if
115 ** highest bit == 1 */
118 /* nasm internal data */
119 struct symbol
*next
; /* next symbol in the list */
120 char *name
; /* name of this symbol */
121 int32_t initial_snum
; /* symbol number used above in
123 int32_t snum
; /* true snum for reloc */
125 /* data that goes into the file */
126 int32_t strx
; /* string table index */
127 uint8_t type
; /* symbol type */
128 uint8_t sect
; /* NO_SECT or section number */
129 int16_t desc
; /* for stab debugging, 0 for us */
130 uint32_t value
; /* offset of symbol in section */
133 /* symbol type bits */
134 #define N_EXT 0x01 /* global or external symbol */
136 #define N_UNDF 0x0 /* undefined symbol | n_sect == */
137 #define N_ABS 0x2 /* absolute symbol | NO_SECT */
138 #define N_SECT 0xe /* defined symbol, n_sect holds
141 #define N_TYPE 0x0e /* type bit mask */
143 #define DEFAULT_SECTION_ALIGNMENT 0 /* byte (i.e. no) alignment */
145 /* special section number values */
146 #define NO_SECT 0 /* no section, invalid */
147 #define MAX_SECT 255 /* maximum number of sections */
149 static struct section
*sects
, **sectstail
;
150 static struct symbol
*syms
, **symstail
;
151 static uint32_t nsyms
;
153 /* These variables are set by macho_layout_symbols() to organize
154 the symbol table and string table in order the dynamic linker
155 expects. They are then used in macho_write() to put out the
156 symbols and strings in that order.
158 The order of the symbol table is:
160 defined external symbols (sorted by name)
161 undefined external symbols (sorted by name)
163 The order of the string table is:
164 strings for external symbols
165 strings for local symbols
167 static uint32_t ilocalsym
= 0;
168 static uint32_t iextdefsym
= 0;
169 static uint32_t iundefsym
= 0;
170 static uint32_t nlocalsym
;
171 static uint32_t nextdefsym
;
172 static uint32_t nundefsym
;
173 static struct symbol
**extdefsyms
= NULL
;
174 static struct symbol
**undefsyms
= NULL
;
176 static struct RAA
*extsyms
;
177 static struct SAA
*strs
;
178 static uint32_t strslen
;
180 static FILE *machofp
;
182 static evalfunc evaluate
;
184 extern struct ofmt of_macho
;
186 /* Global file information. This should be cleaned up into either
187 a structure or as function arguments. */
188 uint32_t head_ncmds
= 0;
189 uint32_t head_sizeofcmds
= 0;
190 uint32_t seg_filesize
= 0;
191 uint32_t seg_vmsize
= 0;
192 uint32_t seg_nsects
= 0;
193 uint32_t rel_padcnt
= 0;
196 #define xstrncpy(xdst, xsrc) \
197 memset(xdst, '\0', sizeof(xdst)); /* zero out whole buffer */ \
198 strncpy(xdst, xsrc, sizeof(xdst)); /* copy over string */ \
199 xdst[sizeof(xdst) - 1] = '\0'; /* proper null-termination */
201 #define align(x, y) \
202 (((x) + (y) - 1) & ~((y) - 1)) /* align x to multiple of y */
204 #define alignint32_t(x) \
205 align(x, sizeof(int32_t)) /* align x to int32_t boundary */
207 static void debug_reloc (struct reloc
*);
208 static void debug_section_relocs (struct section
*) _unused
;
210 static int exact_log2 (uint32_t align
)
214 } else if (align
& (align
-1)) {
215 return -1; /* Not a power of 2 */
218 return __builtin_ctzl (align
);
222 /* We know exactly one bit is set at this point. */
223 if (align
& 0xffff0000)
225 if (align
& 0xff00ff00)
227 if (align
& 0xf0f0f0f0)
229 if (align
& 0xcccccccc)
231 if (align
& 0xaaaaaaaa)
239 static struct section
*get_section_by_name(const char *segname
,
240 const char *sectname
)
244 for (s
= sects
; s
!= NULL
; s
= s
->next
)
245 if (!strcmp(s
->segname
, segname
) && !strcmp(s
->sectname
, sectname
))
251 static struct section
*get_section_by_index(const int32_t index
)
255 for (s
= sects
; s
!= NULL
; s
= s
->next
)
256 if (index
== s
->index
)
262 static int32_t get_section_index_by_name(const char *segname
,
263 const char *sectname
)
267 for (s
= sects
; s
!= NULL
; s
= s
->next
)
268 if (!strcmp(s
->segname
, segname
) && !strcmp(s
->sectname
, sectname
))
274 static char *get_section_name_by_index(const int32_t index
)
278 for (s
= sects
; s
!= NULL
; s
= s
->next
)
279 if (index
== s
->index
)
285 static uint8_t get_section_fileindex_by_index(const int32_t index
)
290 for (s
= sects
; s
!= NULL
&& i
< MAX_SECT
; s
= s
->next
, ++i
)
291 if (index
== s
->index
)
296 "too many sections (>255) - clipped by fileindex");
301 static void macho_init(FILE * fp
, efunc errfunc
, ldfunc ldef
,
310 (void)ldef
; /* placate optimisers */
322 extsyms
= raa_init();
325 /* string table starts with a zero byte - don't ask why */
326 saa_wbytes(strs
, &zero
, sizeof(char));
330 static int macho_setinfo(enum geninfo type
, char **val
)
337 static void sect_write(struct section
*sect
,
338 const uint8_t *data
, uint32_t len
)
340 saa_wbytes(sect
->data
, data
, len
);
344 static void add_reloc(struct section
*sect
, int32_t section
,
345 int pcrel
, int bytes
)
350 /* NeXT as puts relocs in reversed order (address-wise) into the
351 ** files, so we do the same, doesn't seem to make much of a
352 ** difference either way */
353 r
= nasm_malloc(sizeof(struct reloc
));
354 r
->next
= sect
->relocs
;
357 /* the current end of the section will be the symbol's address for
358 ** now, might have to be fixed by macho_fixup_relocs() later on. make
359 ** sure we don't make the symbol scattered by setting the highest
360 ** bit by accident */
361 r
->addr
= sect
->size
& ~R_SCATTERED
;
365 /* match byte count 1, 2, 4 to length codes 0, 1, 2 respectively */
366 r
->length
= bytes
>> 1;
368 /* vanilla relocation (GENERIC_RELOC_VANILLA) */
371 if (section
== NO_SEG
) {
372 /* absolute local symbol if no section index given */
375 fi
= get_section_fileindex_by_index(section
);
378 /* external symbol if no section with that index known,
379 ** symbol number was saved in macho_symdef() */
380 r
->snum
= raa_read(extsyms
, section
);
383 /* local symbol in section fi */
391 static void macho_output(int32_t secto
, const void *data
,
392 enum out_type type
, uint64_t size
,
393 int32_t section
, int32_t wrt
)
395 struct section
*s
, *sbss
;
397 uint8_t mydata
[4], *p
;
401 error(ERR_NONFATAL
, "WRT not supported by Mach-O output format");
402 /* continue to do _something_ */
405 if (secto
== NO_SEG
) {
406 if (type
!= OUT_RESERVE
)
407 error(ERR_NONFATAL
, "attempt to assemble code in "
413 s
= get_section_by_index(secto
);
416 error(ERR_WARNING
, "attempt to assemble code in"
417 " section %d: defaulting to `.text'", secto
);
418 s
= get_section_by_name("__TEXT", "__text");
420 /* should never happen */
422 error(ERR_PANIC
, "text section not found");
425 sbss
= get_section_by_name("__DATA", "__bss");
427 if (s
== sbss
&& type
!= OUT_RESERVE
) {
428 error(ERR_WARNING
, "attempt to initialize memory in the"
429 " BSS section: ignored");
451 error(ERR_WARNING
, "uninitialized space declared in"
452 " %s section: zeroing",
453 get_section_name_by_index(secto
));
455 sect_write(s
, NULL
, size
);
462 if (section
!= NO_SEG
)
463 error(ERR_PANIC
, "OUT_RAWDATA with other than NO_SEG");
465 sect_write(s
, data
, size
);
469 addr
= *(int64_t *)data
;
471 if (section
!= NO_SEG
) {
473 error(ERR_NONFATAL
, "Mach-O format does not support"
474 " section base references");
476 add_reloc(s
, section
, 0, size
);
480 WRITEADDR(p
, addr
, size
);
481 sect_write(s
, mydata
, size
);
485 if (section
== secto
)
486 error(ERR_PANIC
, "intra-section OUT_REL2ADR");
488 if (section
!= NO_SEG
&& section
% 2) {
489 error(ERR_NONFATAL
, "Mach-O format does not support"
490 " section base references");
492 add_reloc(s
, section
, 1, 2);
495 WRITESHORT(p
, *(int32_t *)data
- (size
+ s
->size
));
496 sect_write(s
, mydata
, 2L);
500 if (section
== secto
)
501 error(ERR_PANIC
, "intra-section OUT_REL4ADR");
503 if (section
!= NO_SEG
&& section
% 2) {
504 error(ERR_NONFATAL
, "Mach-O format does not support"
505 " section base references");
507 add_reloc(s
, section
, 1, 4);
510 WRITELONG(p
, *(int32_t *)data
- (size
+ s
->size
));
511 sect_write(s
, mydata
, 4L);
515 error(ERR_PANIC
, "unknown output type?");
520 static int32_t macho_section(char *name
, int pass
, int *bits
)
522 int32_t index
, originalIndex
;
523 char *sectionAttributes
;
529 /* Default to 32 bits. */
533 sectionAttributes
= NULL
;
535 sectionAttributes
= name
;
536 name
= nasm_strsep(§ionAttributes
, " \t");
539 for (sm
= sectmap
; sm
->nasmsect
!= NULL
; ++sm
) {
540 /* make lookup into section name translation table */
541 if (!strcmp(name
, sm
->nasmsect
)) {
542 char *currentAttribute
;
544 /* try to find section with that name */
545 originalIndex
= index
= get_section_index_by_name(sm
->segname
,
548 /* create it if it doesn't exist yet */
550 s
= *sectstail
= nasm_malloc(sizeof(struct section
));
552 sectstail
= &s
->next
;
554 s
->data
= saa_init(1L);
555 s
->index
= seg_alloc();
559 xstrncpy(s
->segname
, sm
->segname
);
560 xstrncpy(s
->sectname
, sm
->sectname
);
563 s
->flags
= sm
->flags
;
567 s
= get_section_by_index(index
);
570 while ((NULL
!= sectionAttributes
)
571 && (currentAttribute
= nasm_strsep(§ionAttributes
, " \t"))) {
572 if (0 != *currentAttribute
) {
573 if (!nasm_strnicmp("align=", currentAttribute
, 6)) {
575 int newAlignment
, value
;
577 value
= strtoul(currentAttribute
+ 6, (char**)&end
, 0);
578 newAlignment
= exact_log2(value
);
582 "unknown or missing alignment value \"%s\" "
583 "specified for section \"%s\"",
584 currentAttribute
+ 6,
587 } else if (0 > newAlignment
) {
589 "alignment of %d (for section \"%s\") is not "
596 if ((-1 != originalIndex
)
597 && (s
->align
!= newAlignment
)
598 && (s
->align
!= -1)) {
600 "section \"%s\" has already been specified "
601 "with alignment %d, conflicts with new "
609 s
->align
= newAlignment
;
610 } else if (!nasm_stricmp("data", currentAttribute
)) {
611 /* Do nothing; 'data' is implicit */
614 "unknown section attribute %s for section %s",
626 error(ERR_PANIC
, "invalid section name %s", name
);
630 static void macho_symdef(char *name
, int32_t section
, int64_t offset
,
631 int is_global
, char *special
)
636 error(ERR_NONFATAL
, "The Mach-O output format does "
637 "not support any special symbol types");
641 if (is_global
== 3) {
642 error(ERR_NONFATAL
, "The Mach-O format does not "
643 "(yet) support forward reference fixups.");
647 sym
= *symstail
= nasm_malloc(sizeof(struct symbol
));
649 symstail
= &sym
->next
;
656 sym
->initial_snum
= -1;
658 /* external and common symbols get N_EXT */
662 if (section
== NO_SEG
) {
663 /* symbols in no section get absolute */
669 /* get the in-file index of the section the symbol was defined in */
670 sym
->sect
= get_section_fileindex_by_index(section
);
672 if (sym
->sect
== NO_SECT
) {
673 /* remember symbol number of references to external
674 ** symbols, this works because every external symbol gets
675 ** its own section number allocated internally by nasm and
676 ** can so be used as a key */
677 extsyms
= raa_write(extsyms
, section
, nsyms
);
678 sym
->initial_snum
= nsyms
;
683 /* there isn't actually a difference between global
684 ** and common symbols, both even have their size in
690 /* give an error on unfound section if it's not an
691 ** external or common symbol (assemble_file() does a
692 ** seg_alloc() on every call for them) */
693 error(ERR_PANIC
, "in-file index for section %d not found",
702 static int32_t macho_segbase(int32_t section
)
707 static int macho_directive(char *directive
, char *value
, int pass
)
715 static void macho_filename(char *inname
, char *outname
, efunc error
)
717 standard_extension(inname
, outname
, ".o", error
);
720 static const char *macho_stdmac
[] = {
721 "%define __SECT__ [section .text]",
722 "%macro __NASM_CDecl__ 1",
727 /* Comparison function for qsort symbol layout. */
728 static int layout_compare (const struct symbol
**s1
,
729 const struct symbol
**s2
)
731 return (strcmp ((*s1
)->name
, (*s2
)->name
));
734 /* The native assembler does a few things in a similar function
736 * Remove temporary labels
737 * Sort symbols according to local, external, undefined (by name)
738 * Order the string table
740 We do not remove temporary labels right now.
742 numsyms is the total number of symbols we have. strtabsize is the
743 number entries in the string table. */
745 static void macho_layout_symbols (uint32_t *numsyms
,
746 uint32_t *strtabsize
)
748 struct symbol
*sym
, **symp
;
752 *strtabsize
= sizeof (char);
756 while ((sym
= *symp
)) {
757 /* Undefined symbols are now external. */
758 if (sym
->type
== N_UNDF
)
761 if ((sym
->type
& N_EXT
) == 0) {
762 sym
->snum
= *numsyms
;
763 *numsyms
= *numsyms
+ 1;
767 if ((sym
->type
& N_TYPE
) != N_UNDF
)
772 /* If we handle debug info we'll want
773 to check for it here instead of just
774 adding the symbol to the string table. */
775 sym
->strx
= *strtabsize
;
776 saa_wbytes (strs
, sym
->name
, (int32_t)(strlen(sym
->name
) + 1));
777 *strtabsize
+= strlen(sym
->name
) + 1;
782 /* Next, sort the symbols. Most of this code is a direct translation from
783 the Apple cctools symbol layout. We need to keep compatibility with that. */
784 /* Set the indexes for symbol groups into the symbol table */
786 iextdefsym
= nlocalsym
;
787 iundefsym
= nlocalsym
+ nextdefsym
;
789 /* allocate arrays for sorting externals by name */
790 extdefsyms
= nasm_malloc(nextdefsym
* sizeof(struct symbol
*));
791 undefsyms
= nasm_malloc(nundefsym
* sizeof(struct symbol
*));
798 while ((sym
= *symp
)) {
800 if((sym
->type
& N_EXT
) == 0) {
801 sym
->strx
= *strtabsize
;
802 saa_wbytes (strs
, sym
->name
, (int32_t)(strlen (sym
->name
) + 1));
803 *strtabsize
+= strlen(sym
->name
) + 1;
806 if((sym
->type
& N_TYPE
) != N_UNDF
)
807 extdefsyms
[i
++] = sym
;
809 undefsyms
[j
++] = sym
;
814 qsort(extdefsyms
, nextdefsym
, sizeof(struct symbol
*),
815 (int (*)(const void *, const void *))layout_compare
);
816 qsort(undefsyms
, nundefsym
, sizeof(struct symbol
*),
817 (int (*)(const void *, const void *))layout_compare
);
819 for(i
= 0; i
< nextdefsym
; i
++) {
820 extdefsyms
[i
]->snum
= *numsyms
;
823 for(j
= 0; j
< nundefsym
; j
++) {
824 undefsyms
[j
]->snum
= *numsyms
;
829 /* Calculate some values we'll need for writing later. */
831 static void macho_calculate_sizes (void)
835 /* count sections and calculate in-memory and in-file offsets */
836 for (s
= sects
; s
!= NULL
; s
= s
->next
) {
837 /* zerofill sections aren't actually written to the file */
838 if ((s
->flags
& SECTION_TYPE
) != S_ZEROFILL
)
839 seg_filesize
+= s
->size
;
841 seg_vmsize
+= s
->size
;
845 /* calculate size of all headers, load commands and sections to
846 ** get a pointer to the start of all the raw data */
847 if (seg_nsects
> 0) {
850 MACHO_SEGCMD_SIZE
+ seg_nsects
* MACHO_SECTCMD_SIZE
;
855 head_sizeofcmds
+= MACHO_SYMCMD_SIZE
;
859 /* Write out the header information for the file. */
861 static void macho_write_header (void)
863 fwriteint32_t(MH_MAGIC
, machofp
); /* magic */
864 fwriteint32_t(CPU_TYPE_I386
, machofp
); /* CPU type */
865 fwriteint32_t(CPU_SUBTYPE_I386_ALL
, machofp
); /* CPU subtype */
866 fwriteint32_t(MH_OBJECT
, machofp
); /* Mach-O file type */
867 fwriteint32_t(head_ncmds
, machofp
); /* number of load commands */
868 fwriteint32_t(head_sizeofcmds
, machofp
); /* size of load commands */
869 fwriteint32_t(0, machofp
); /* no flags */
872 /* Write out the segment load command at offset. */
874 static uint32_t macho_write_segment (uint32_t offset
)
877 uint32_t rel_base
= alignint32_t (offset
+ seg_filesize
);
878 uint32_t s_reloff
= 0;
881 fwriteint32_t(LC_SEGMENT
, machofp
); /* cmd == LC_SEGMENT */
883 /* size of load command including section load commands */
884 fwriteint32_t(MACHO_SEGCMD_SIZE
+ seg_nsects
*
885 MACHO_SECTCMD_SIZE
, machofp
);
887 /* in an MH_OBJECT file all sections are in one unnamed (name
888 ** all zeros) segment */
889 fwrite("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 16, 1, machofp
);
890 fwriteint32_t(0, machofp
); /* in-memory offset */
891 fwriteint32_t(seg_vmsize
, machofp
); /* in-memory size */
892 fwriteint32_t(offset
, machofp
); /* in-file offset to data */
893 fwriteint32_t(seg_filesize
, machofp
); /* in-file size */
894 fwriteint32_t(VM_PROT_DEFAULT
, machofp
); /* maximum vm protection */
895 fwriteint32_t(VM_PROT_DEFAULT
, machofp
); /* initial vm protection */
896 fwriteint32_t(seg_nsects
, machofp
); /* number of sections */
897 fwriteint32_t(0, machofp
); /* no flags */
899 /* emit section headers */
900 for (s
= sects
; s
!= NULL
; s
= s
->next
) {
901 fwrite(s
->sectname
, sizeof(s
->sectname
), 1, machofp
);
902 fwrite(s
->segname
, sizeof(s
->segname
), 1, machofp
);
903 fwriteint32_t(s_addr
, machofp
);
904 fwriteint32_t(s
->size
, machofp
);
906 /* dummy data for zerofill sections or proper values */
907 if ((s
->flags
& SECTION_TYPE
) != S_ZEROFILL
) {
908 fwriteint32_t(offset
, machofp
);
909 /* Write out section alignment, as a power of two.
910 e.g. 32-bit word alignment would be 2 (2^^2 = 4). */
912 s
->align
= DEFAULT_SECTION_ALIGNMENT
;
913 fwriteint32_t(s
->align
, machofp
);
914 /* To be compatible with cctools as we emit
915 a zero reloff if we have no relocations. */
916 fwriteint32_t(s
->nreloc
? rel_base
+ s_reloff
: 0, machofp
);
917 fwriteint32_t(s
->nreloc
, machofp
);
920 s_reloff
+= s
->nreloc
* MACHO_RELINFO_SIZE
;
922 fwriteint32_t(0, machofp
);
923 fwriteint32_t(0, machofp
);
924 fwriteint32_t(0, machofp
);
925 fwriteint32_t(0, machofp
);
928 fwriteint32_t(s
->flags
, machofp
); /* flags */
929 fwriteint32_t(0, machofp
); /* reserved */
930 fwriteint32_t(0, machofp
); /* reserved */
935 rel_padcnt
= rel_base
- offset
;
936 offset
= rel_base
+ s_reloff
;
941 /* For a given chain of relocs r, write out the entire relocation
942 chain to the object file. */
944 static void macho_write_relocs (struct reloc
*r
)
949 fwriteint32_t(r
->addr
, machofp
); /* reloc offset */
952 word2
|= r
->pcrel
<< 24;
953 word2
|= r
->length
<< 25;
954 word2
|= r
->ext
<< 27;
955 word2
|= r
->type
<< 28;
956 fwriteint32_t(word2
, machofp
); /* reloc data */
962 /* Write out the section data. */
963 static void macho_write_section (void)
965 struct section
*s
, *s2
;
967 char *rel_paddata
= "\0\0\0";
968 uint8_t fi
, *p
, *q
, blk
[4];
971 for (s
= sects
; s
!= NULL
; s
= s
->next
) {
972 if ((s
->flags
& SECTION_TYPE
) == S_ZEROFILL
)
975 /* no padding needs to be done to the sections */
977 /* Like a.out Mach-O references things in the data or bss
978 * sections by addresses which are actually relative to the
979 * start of the _text_ section, in the _file_. See outaout.c
980 * for more information. */
982 for (r
= s
->relocs
; r
!= NULL
; r
= r
->next
) {
983 saa_fread(s
->data
, r
->addr
, blk
, (int32_t)r
->length
<< 1);
987 /* get offset based on relocation type */
989 l
+= ((int32_t)*p
++) << 8;
991 if (r
->length
== 2) {
992 l
+= ((int32_t)*p
++) << 16;
993 l
+= ((int32_t)*p
++) << 24;
997 /* If the relocation is internal add to the current section
998 offset. Otherwise the only value we need is the symbol
999 offset which we already have. The linker takes care
1000 of the rest of the address. */
1002 /* add sizes of previous sections to current offset */
1003 for (s2
= sects
, fi
= 1;
1004 s2
!= NULL
&& fi
< r
->snum
; s2
= s2
->next
, fi
++)
1008 /* write new offset back */
1011 else if (r
->length
== 1)
1016 saa_fwrite(s
->data
, r
->addr
, blk
, (int32_t)r
->length
<< 1);
1019 /* dump the section data to file */
1020 saa_fpwrite(s
->data
, machofp
);
1023 /* pad last section up to reloc entries on int32_t boundary */
1024 fwrite(rel_paddata
, rel_padcnt
, 1, machofp
);
1026 /* emit relocation entries */
1027 for (s
= sects
; s
!= NULL
; s
= s
->next
)
1028 macho_write_relocs (s
->relocs
);
1031 /* Write out the symbol table. We should already have sorted this
1033 static void macho_write_symtab (void)
1040 /* we don't need to pad here since MACHO_RELINFO_SIZE == 8 */
1042 for (sym
= syms
; sym
!= NULL
; sym
= sym
->next
) {
1043 if ((sym
->type
& N_EXT
) == 0) {
1044 fwriteint32_t(sym
->strx
, machofp
); /* string table entry number */
1045 fwrite(&sym
->type
, 1, 1, machofp
); /* symbol type */
1046 fwrite(&sym
->sect
, 1, 1, machofp
); /* section */
1047 fwriteint16_t(sym
->desc
, machofp
); /* description */
1049 /* Fix up the symbol value now that we know the final section
1051 if (((sym
->type
& N_TYPE
) == N_SECT
) && (sym
->sect
!= NO_SECT
)) {
1052 for (s
= sects
, fi
= 1;
1053 s
!= NULL
&& fi
< sym
->sect
; s
= s
->next
, ++fi
)
1054 sym
->value
+= s
->size
;
1057 fwriteint32_t(sym
->value
, machofp
); /* value (i.e. offset) */
1061 for (i
= 0; i
< nextdefsym
; i
++) {
1062 sym
= extdefsyms
[i
];
1063 fwriteint32_t(sym
->strx
, machofp
);
1064 fwrite(&sym
->type
, 1, 1, machofp
); /* symbol type */
1065 fwrite(&sym
->sect
, 1, 1, machofp
); /* section */
1066 fwriteint16_t(sym
->desc
, machofp
); /* description */
1068 /* Fix up the symbol value now that we know the final section
1070 if (((sym
->type
& N_TYPE
) == N_SECT
) && (sym
->sect
!= NO_SECT
)) {
1071 for (s
= sects
, fi
= 1;
1072 s
!= NULL
&& fi
< sym
->sect
; s
= s
->next
, ++fi
)
1073 sym
->value
+= s
->size
;
1076 fwriteint32_t(sym
->value
, machofp
); /* value (i.e. offset) */
1079 for (i
= 0; i
< nundefsym
; i
++) {
1081 fwriteint32_t(sym
->strx
, machofp
);
1082 fwrite(&sym
->type
, 1, 1, machofp
); /* symbol type */
1083 fwrite(&sym
->sect
, 1, 1, machofp
); /* section */
1084 fwriteint16_t(sym
->desc
, machofp
); /* description */
1086 /* Fix up the symbol value now that we know the final section
1088 if (((sym
->type
& N_TYPE
) == N_SECT
) && (sym
->sect
!= NO_SECT
)) {
1089 for (s
= sects
, fi
= 1;
1090 s
!= NULL
&& fi
< sym
->sect
; s
= s
->next
, ++fi
)
1091 sym
->value
+= s
->size
;
1094 fwriteint32_t(sym
->value
, machofp
); /* value (i.e. offset) */
1098 /* Fixup the snum in the relocation entries, we should be
1099 doing this only for externally undefined symbols. */
1100 static void macho_fixup_relocs (struct reloc
*r
)
1107 for (i
= 0; i
< nundefsym
; i
++) {
1109 if (sym
->initial_snum
== r
->snum
) {
1110 r
->snum
= sym
->snum
;
1119 /* Write out the object file. */
1121 static void macho_write (void)
1123 uint32_t offset
= 0;
1125 /* mach-o object file structure:
1131 ** uint32_t mach file type
1132 ** uint32_t number of load commands
1133 ** uint32_t size of all load commands
1134 ** (includes section struct size of segment command)
1138 ** uint32_t command type == LC_SEGMENT
1139 ** uint32_t size of load command
1140 ** (including section load commands)
1141 ** char[16] segment name
1142 ** uint32_t in-memory offset
1143 ** uint32_t in-memory size
1144 ** uint32_t in-file offset to data area
1145 ** uint32_t in-file size
1146 ** (in-memory size excluding zerofill sections)
1147 ** int maximum vm protection
1148 ** int initial vm protection
1149 ** uint32_t number of sections
1153 ** char[16] section name
1154 ** char[16] segment name
1155 ** uint32_t in-memory offset
1156 ** uint32_t in-memory size
1157 ** uint32_t in-file offset
1158 ** uint32_t alignment
1159 ** (irrelevant in MH_OBJECT)
1160 ** uint32_t in-file offset of relocation entires
1161 ** uint32_t number of relocations
1163 ** uint32_t reserved
1164 ** uint32_t reserved
1166 ** symbol table command
1167 ** uint32_t command type == LC_SYMTAB
1168 ** uint32_t size of load command
1169 ** uint32_t symbol table offset
1170 ** uint32_t number of symbol table entries
1171 ** uint32_t string table offset
1172 ** uint32_t string table size
1176 ** padding to int32_t boundary
1178 ** relocation data (struct reloc)
1180 ** uint data (symbolnum, pcrel, length, extern, type)
1182 ** symbol table data (struct nlist)
1183 ** int32_t string table entry number
1185 ** (extern, absolute, defined in section)
1187 ** (0 for global symbols, section number of definition (>= 1, <=
1188 ** 254) for local symbols, size of variable for common symbols
1189 ** [type == extern])
1190 ** int16_t description
1191 ** (for stab debugging format)
1192 ** uint32_t value (i.e. file offset) of symbol or stab offset
1194 ** string table data
1195 ** list of null-terminated strings
1198 /* Emit the Mach-O header. */
1199 macho_write_header();
1201 offset
= MACHO_HEADER_SIZE
+ head_sizeofcmds
;
1203 /* emit the segment load command */
1205 offset
= macho_write_segment (offset
);
1207 error(ERR_WARNING
, "no sections?");
1210 /* write out symbol command */
1211 fwriteint32_t(LC_SYMTAB
, machofp
); /* cmd == LC_SYMTAB */
1212 fwriteint32_t(MACHO_SYMCMD_SIZE
, machofp
); /* size of load command */
1213 fwriteint32_t(offset
, machofp
); /* symbol table offset */
1214 fwriteint32_t(nsyms
, machofp
); /* number of symbol
1217 offset
+= nsyms
* MACHO_NLIST_SIZE
;
1218 fwriteint32_t(offset
, machofp
); /* string table offset */
1219 fwriteint32_t(strslen
, machofp
); /* string table size */
1222 /* emit section data */
1224 macho_write_section ();
1226 /* emit symbol table if we have symbols */
1228 macho_write_symtab ();
1230 /* we don't need to pad here since MACHO_NLIST_SIZE == 12 */
1232 /* emit string table */
1233 saa_fpwrite(strs
, machofp
);
1235 /* We do quite a bit here, starting with finalizing all of the data
1236 for the object file, writing, and then freeing all of the data from
1239 static void macho_cleanup(int debuginfo
)
1247 /* Sort all symbols. */
1248 macho_layout_symbols (&nsyms
, &strslen
);
1250 /* Fixup relocation entries */
1251 for (s
= sects
; s
!= NULL
; s
= s
->next
) {
1252 macho_fixup_relocs (s
->relocs
);
1255 /* First calculate and finalize needed values. */
1256 macho_calculate_sizes();
1262 /* free up everything */
1263 while (sects
->next
) {
1265 sects
= sects
->next
;
1268 while (s
->relocs
!= NULL
) {
1270 s
->relocs
= s
->relocs
->next
;
1281 while (syms
->next
) {
1290 /* Debugging routines. */
1291 static void debug_reloc (struct reloc
*r
)
1293 fprintf (stdout
, "reloc:\n");
1294 fprintf (stdout
, "\taddr: %"PRId32
"\n", r
->addr
);
1295 fprintf (stdout
, "\tsnum: %d\n", r
->snum
);
1296 fprintf (stdout
, "\tpcrel: %d\n", r
->pcrel
);
1297 fprintf (stdout
, "\tlength: %d\n", r
->length
);
1298 fprintf (stdout
, "\text: %d\n", r
->ext
);
1299 fprintf (stdout
, "\ttype: %d\n", r
->type
);
1302 static void debug_section_relocs (struct section
*s
)
1304 struct reloc
*r
= s
->relocs
;
1306 fprintf (stdout
, "relocs for section %s:\n\n", s
->sectname
);
1314 struct ofmt of_macho
= {
1315 "NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X object files",