?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
preproc: formatting cleanups
[nasm.git] / output / outmacho64.c
blobd3f5a8e8cde2e24b2758c203d56e16fa0efa7c18
1 /* ----------------------------------------------------------------------- *
2 *
3 * Copyright 1996-2009 The NASM Authors - All Rights Reserved
4 * See the file AUTHORS included with the NASM distribution for
5 * the specific copyright holders.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
9 * conditions are met:
10 *
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer in the documentation and/or other materials provided
16 * with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
19 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 *
32 * ----------------------------------------------------------------------- */
33
34 /*
35 * outmacho64.c output routines for the Netwide Assembler to produce
36 * NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X (x86_64) object files
37 */
38
39 /* Most of this file is, like Mach-O itself, based on a.out. For more
40 * guidelines see outaout.c. */
41
42 #include "compiler.h"
43
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <string.h>
47 #include <ctype.h>
48 #include <inttypes.h>
49
50 #include "nasm.h"
51 #include "nasmlib.h"
52 #include "saa.h"
53 #include "raa.h"
54 #include "output/outform.h"
55 #include "output/outlib.h"
56
57 #if defined(OF_MACHO64)
58
59 /* Mach-O in-file header structure sizes */
60 #define MACHO_HEADER64_SIZE (32)
61 #define MACHO_SEGCMD64_SIZE (72)
62 #define MACHO_SECTCMD64_SIZE (80)
63 #define MACHO_SYMCMD_SIZE (24)
64 #define MACHO_NLIST64_SIZE (16)
65 #define MACHO_RELINFO64_SIZE (8)
66
67 /* Mach-O file header values */
68 #define MH_MAGIC_64 (0xfeedfacf)
69 #define CPU_TYPE_X86_64 (0x01000007) /* x86-64 platform */
70 #define CPU_SUBTYPE_I386_ALL (3) /* all-x86 compatible */
71 #define MH_OBJECT (0x1) /* object file */
72
73 #define LC_SEGMENT_64 (0x19) /* segment load command */
74 #define LC_SYMTAB (0x2) /* symbol table load command */
75
76 #define VM_PROT_NONE (0x00)
77 #define VM_PROT_READ (0x01)
78 #define VM_PROT_WRITE (0x02)
79 #define VM_PROT_EXECUTE (0x04)
80
81 #define VM_PROT_DEFAULT (VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE)
82 #define VM_PROT_ALL (VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE)
83
84 struct section {
85 /* nasm internal data */
86 struct section *next;
87 struct SAA *data;
88 int32_t index;
89 struct reloc *relocs;
90 int align;
91
92 /* data that goes into the file */
93 char sectname[16]; /* what this section is called */
94 char segname[16]; /* segment this section will be in */
95 uint64_t addr; /* in-memory address (subject to alignment) */
96 uint64_t size; /* in-memory and -file size */
97 uint32_t nreloc; /* relocation entry count */
98 uint32_t flags; /* type and attributes (masked) */
99 uint32_t extreloc; /* external relocations */
100 };
101
102 #define SECTION_TYPE 0x000000ff /* section type mask */
103
104 #define S_REGULAR (0x0) /* standard section */
105 #define S_ZEROFILL (0x1) /* zerofill, in-memory only */
106
107 #define SECTION_ATTRIBUTES_SYS 0x00ffff00 /* system setable attributes */
108 #define S_ATTR_SOME_INSTRUCTIONS 0x00000400 /* section contains some
109 machine instructions */
110 #define S_ATTR_EXT_RELOC 0x00000200 /* section has external
111 relocation entries */
112 #define S_ATTR_LOC_RELOC 0x00000100 /* section has local
113 relocation entries */
114 #define S_ATTR_PURE_INSTRUCTIONS 0x80000000 /* section uses pure
115 machine instructions */
116
117 static struct sectmap {
118 const char *nasmsect;
119 const char *segname;
120 const char *sectname;
121 const int32_t flags;
122 } sectmap[] = {
123 {".text", "__TEXT", "__text", S_REGULAR|S_ATTR_SOME_INSTRUCTIONS|S_ATTR_PURE_INSTRUCTIONS},
124 {".data", "__DATA", "__data", S_REGULAR},
125 {".rodata", "__DATA", "__const", S_REGULAR},
126 {".bss", "__DATA", "__bss", S_ZEROFILL},
127 {NULL, NULL, NULL, 0}
128 };
129
130 struct reloc {
131 /* nasm internal data */
132 struct reloc *next;
133
134 /* data that goes into the file */
135 int32_t addr; /* op's offset in section */
136 uint32_t snum:24, /* contains symbol index if
137 ** ext otherwise in-file
138 ** section number */
139 pcrel:1, /* relative relocation */
140 length:2, /* 0=byte, 1=word, 2=int32_t, 3=int64_t */
141 ext:1, /* external symbol referenced */
142 type:4; /* reloc type */
143 };
144
145 #define R_ABS 0 /* absolute relocation */
146 #define R_SCATTERED 0x80000000 /* reloc entry is scattered if
147 ** highest bit == 1 */
148
149 struct symbol {
150 /* nasm internal data */
151 struct symbol *next; /* next symbol in the list */
152 char *name; /* name of this symbol */
153 int32_t initial_snum; /* symbol number used above in
154 reloc */
155 int32_t snum; /* true snum for reloc */
156
157 /* data that goes into the file */
158 uint32_t strx; /* string table index */
159 uint8_t type; /* symbol type */
160 uint8_t sect; /* NO_SECT or section number */
161 uint16_t desc; /* for stab debugging, 0 for us */
162 uint64_t value; /* offset of symbol in section */
163 };
164
165 /* symbol type bits */
166 #define N_EXT 0x01 /* global or external symbol */
167
168 #define N_UNDF 0x0 /* undefined symbol | n_sect == */
169 #define N_ABS 0x2 /* absolute symbol | NO_SECT */
170 #define N_SECT 0xe /* defined symbol, n_sect holds
171 ** section number */
172
173 #define N_TYPE 0x0e /* type bit mask */
174
175 #define DEFAULT_SECTION_ALIGNMENT 0 /* byte (i.e. no) alignment */
176
177 /* special section number values */
178 #define NO_SECT 0 /* no section, invalid */
179 #define MAX_SECT 255 /* maximum number of sections */
180
181 static struct section *sects, **sectstail;
182 static struct symbol *syms, **symstail;
183 static uint32_t nsyms;
184
185 /* These variables are set by macho_layout_symbols() to organize
186 the symbol table and string table in order the dynamic linker
187 expects. They are then used in macho_write() to put out the
188 symbols and strings in that order.
189
190 The order of the symbol table is:
191 local symbols
192 defined external symbols (sorted by name)
193 undefined external symbols (sorted by name)
194
195 The order of the string table is:
196 strings for external symbols
197 strings for local symbols
198 */
199 static uint32_t ilocalsym = 0;
200 static uint32_t iextdefsym = 0;
201 static uint32_t iundefsym = 0;
202 static uint32_t nlocalsym;
203 static uint32_t nextdefsym;
204 static uint32_t nundefsym;
205 static struct symbol **extdefsyms = NULL;
206 static struct symbol **undefsyms = NULL;
207
208 static struct RAA *extsyms;
209 static struct SAA *strs;
210 static uint32_t strslen;
211
212 static FILE *machofp;
213 static efunc error;
214 static evalfunc evaluate;
215
216 extern struct ofmt of_macho64;
217
218 /* Global file information. This should be cleaned up into either
219 a structure or as function arguments. */
220 uint32_t head_ncmds64 = 0;
221 uint32_t head_sizeofcmds64 = 0;
222 uint64_t seg_filesize64 = 0;
223 uint64_t seg_vmsize64 = 0;
224 uint32_t seg_nsects64 = 0;
225 uint64_t rel_padcnt64 = 0;
226
227
228 #define xstrncpy(xdst, xsrc) \
229 memset(xdst, '\0', sizeof(xdst)); /* zero out whole buffer */ \
230 strncpy(xdst, xsrc, sizeof(xdst)); /* copy over string */ \
231 xdst[sizeof(xdst) - 1] = '\0'; /* proper null-termination */
232
233 #define align(x, y) \
234 (((x) + (y) - 1) & ~((y) - 1)) /* align x to multiple of y */
235
236 #define alignint32_t(x) \
237 align(x, sizeof(int32_t)) /* align x to int32_t boundary */
238
239 #define alignint64_t(x) \
240 align(x, sizeof(int64_t)) /* align x to int64_t boundary */
241
242 static void debug_reloc (struct reloc *);
243 static void debug_section_relocs (struct section *) _unused;
244
245 static int exact_log2 (uint32_t align)
246 {
247 if (align == 0) {
248 return 0;
249 } else if (align & (align-1)) {
250 return -1; /* Not a power of 2 */
251 } else {
252 #ifdef HAVE_GNUC_4
253 return __builtin_ctzl (align);
254 #else
255 uint32_t result = 0;
256
257 /* We know exactly one bit is set at this point. */
258 if (align & 0xffff0000)
259 result |= 16;
260 if (align & 0xff00ff00)
261 result |= 8;
262 if (align & 0xf0f0f0f0)
263 result |= 4;
264 if (align & 0xcccccccc)
265 result |= 2;
266 if (align & 0xaaaaaaaa)
267 result |= 1;
268
269 return result;
270 #endif
271 }
272 }
273
274 static struct section *get_section_by_name(const char *segname,
275 const char *sectname)
276 {
277 struct section *s;
278
279 for (s = sects; s != NULL; s = s->next)
280 if (!strcmp(s->segname, segname) && !strcmp(s->sectname, sectname))
281 break;
282
283 return s;
284 }
285
286 static struct section *get_section_by_index(const int32_t index)
287 {
288 struct section *s;
289
290 for (s = sects; s != NULL; s = s->next)
291 if (index == s->index)
292 break;
293
294 return s;
295 }
296
297 static int32_t get_section_index_by_name(const char *segname,
298 const char *sectname)
299 {
300 struct section *s;
301
302 for (s = sects; s != NULL; s = s->next)
303 if (!strcmp(s->segname, segname) && !strcmp(s->sectname, sectname))
304 return s->index;
305
306 return -1;
307 }
308
309 static char *get_section_name_by_index(const int32_t index)
310 {
311 struct section *s;
312
313 for (s = sects; s != NULL; s = s->next)
314 if (index == s->index)
315 return s->sectname;
316
317 return NULL;
318 }
319
320 static uint8_t get_section_fileindex_by_index(const int32_t index)
321 {
322 struct section *s;
323 uint8_t i = 1;
324
325 for (s = sects; s != NULL && i < MAX_SECT; s = s->next, ++i)
326 if (index == s->index)
327 return i;
328
329 if (i == MAX_SECT)
330 error(ERR_WARNING,
331 "too many sections (>255) - clipped by fileindex");
332
333 return NO_SECT;
334 }
335
336 static struct symbol *get_closest_section_symbol_by_offset(uint8_t fileindex, int64_t offset)
337 {
338 struct symbol *sym;
339
340 for (sym = syms; sym != NULL; sym = sym->next) {
341 if ((sym->sect != NO_SECT) &&
342 (sym->sect == fileindex) &&
343 ((int64_t)sym->value >= offset))
344 return sym;
345 }
346
347 return NULL;
348 }
349
350
351 /*
352 * Special section numbers which are used to define Mach-O special
353 * symbols, which can be used with WRT to provide PIC relocation
354 * types.
355 */
356 static int32_t macho_gotpcrel_sect;
357
358 static void macho_init(FILE * fp, efunc errfunc, ldfunc ldef,
359 evalfunc eval)
360 {
361 char zero = 0;
362
363 maxbits = 64;
364 machofp = fp;
365 error = errfunc;
366 evaluate = eval;
367
368 (void)ldef; /* placate optimizers */
369
370 sects = NULL;
371 sectstail = &sects;
372
373 syms = NULL;
374 symstail = &syms;
375 nsyms = 0;
376 nlocalsym = 0;
377 nextdefsym = 0;
378 nundefsym = 0;
379
380 extsyms = raa_init();
381 strs = saa_init(1L);
382
383 /* string table starts with a zero byte - don't ask why */
384 saa_wbytes(strs, &zero, sizeof(char));
385 strslen = 1;
386
387 /* add special symbol for ..gotpcrel */
388 macho_gotpcrel_sect = seg_alloc();
389 macho_gotpcrel_sect ++;
390 ldef("..gotpcrel", macho_gotpcrel_sect, 0L, NULL, false, false, &of_macho64, error);
391 }
392
393 static void sect_write(struct section *sect,
394 const uint8_t *data, uint32_t len)
395 {
396 saa_wbytes(sect->data, data, len);
397 sect->size += len;
398 }
399
400 static int32_t add_reloc(struct section *sect, int32_t section,
401 int pcrel, int bytes, int64_t reloff)
402 {
403 struct reloc *r;
404 struct symbol *sym;
405 int32_t fi;
406 int32_t adjustment = 0;
407
408 /* NeXT as puts relocs in reversed order (address-wise) into the
409 ** files, so we do the same, doesn't seem to make much of a
410 ** difference either way */
411 r = nasm_malloc(sizeof(struct reloc));
412 r->next = sect->relocs;
413 sect->relocs = r;
414
415 /* the current end of the section will be the symbol's address for
416 ** now, might have to be fixed by macho_fixup_relocs() later on. make
417 ** sure we don't make the symbol scattered by setting the highest
418 ** bit by accident */
419 r->addr = sect->size & ~R_SCATTERED;
420 r->ext = 1;
421 r->pcrel = (pcrel ? 1 : 0);
422
423 /* match byte count 1, 2, 4, 8 to length codes 0, 1, 2, 3 respectively */
424 switch(bytes){
425 case 1:
426 r->length = 0;
427 break;
428 case 2:
429 r->length = 1;
430 break;
431 case 4:
432 r->length = 2;
433 break;
434 case 8:
435 r->length = 3;
436 break;
437 default:
438 break;
439 }
440
441 /* set default relocation values */
442 r->type = 0; // X86_64_RELOC_UNSIGNED
443 r->snum = R_ABS; // Absolute Symbol (indicates no relocation)
444
445 /* absolute relocation */
446 if (pcrel == 0) {
447
448 /* intra-section */
449 if (section == NO_SEG) {
450 // r->snum = R_ABS; // Set above
451
452 /* inter-section */
453 } else {
454 fi = get_section_fileindex_by_index(section);
455
456 /* external */
457 if (fi == NO_SECT) {
458 r->snum = raa_read(extsyms, section);
459
460 /* local */
461 } else {
462 sym = get_closest_section_symbol_by_offset(fi, reloff);
463 r->snum = sym->initial_snum;
464 adjustment = sym->value;
465 }
466 }
467
468 /* relative relocation */
469 } else if (pcrel == 1) {
470
471 /* intra-section */
472 if (section == NO_SEG) {
473 r->type = 1; // X86_64_RELOC_SIGNED
474
475 /* inter-section */
476 } else {
477 r->type = 2; // X86_64_RELOC_BRANCH
478 fi = get_section_fileindex_by_index(section);
479
480 /* external */
481 if (fi == NO_SECT) {
482 sect->extreloc = 1;
483 r->snum = raa_read(extsyms, section);
484
485 /* local */
486 } else {
487 sym = get_closest_section_symbol_by_offset(fi, reloff);
488 r->snum = sym->initial_snum;
489 adjustment = sym->value;
490 }
491 }
492
493 /* subtractor */
494 } else if (pcrel == 2) {
495 r->pcrel = 0;
496 r->type = 5; // X86_64_RELOC_SUBTRACTOR
497
498 /* gotpcrel */
499 } else if (pcrel == 3) {
500 r->type = 4; // X86_64_RELOC_GOT
501 r->snum = macho_gotpcrel_sect;
502
503 /* gotpcrel MOVQ load */
504 } else if (pcrel == 4) {
505 r->type = 3; // X86_64_RELOC_GOT_LOAD
506 r->snum = macho_gotpcrel_sect;
507 }
508
509 ++sect->nreloc;
510
511 return adjustment;
512 }
513
514 static void macho_output(int32_t secto, const void *data,
515 enum out_type type, uint64_t size,
516 int32_t section, int32_t wrt)
517 {
518 struct section *s, *sbss;
519 int64_t addr;
520 uint8_t mydata[16], *p, gotload;
521
522 if (secto == NO_SEG) {
523 if (type != OUT_RESERVE)
524 error(ERR_NONFATAL, "attempt to assemble code in "
525 "[ABSOLUTE] space");
526
527 return;
528 }
529
530 s = get_section_by_index(secto);
531
532 if (s == NULL) {
533 error(ERR_WARNING, "attempt to assemble code in"
534 " section %d: defaulting to `.text'", secto);
535 s = get_section_by_name("__TEXT", "__text");
536
537 /* should never happen */
538 if (s == NULL)
539 error(ERR_PANIC, "text section not found");
540 }
541
542 sbss = get_section_by_name("__DATA", "__bss");
543
544 if (s == sbss && type != OUT_RESERVE) {
545 error(ERR_WARNING, "attempt to initialize memory in the"
546 " BSS section: ignored");
547 s->size += realsize(type, size);
548 return;
549 }
550
551 switch (type) {
552 case OUT_RESERVE:
553 if (s != sbss) {
554 error(ERR_WARNING, "uninitialized space declared in"
555 " %s section: zeroing",
556 get_section_name_by_index(secto));
557
558 sect_write(s, NULL, size);
559 } else
560 s->size += size;
561
562 break;
563
564 case OUT_RAWDATA:
565 if (section != NO_SEG)
566 error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
567
568 sect_write(s, data, size);
569 break;
570
571 case OUT_ADDRESS:
572 addr = *(int64_t *)data;
573 if (section != NO_SEG) {
574 if (section % 2) {
575 error(ERR_NONFATAL, "Mach-O format does not support"
576 " section base references");
577 } else {
578 if (wrt == NO_SEG) {
579 if (size < 8) {
580 error(ERR_NONFATAL, "Mach-O 64-bit format does not support"
581 " 32-bit absolute addresses");
582 /*
583 Seemingly, Mach-O's X86_64_RELOC_SUBTRACTOR would require
584 pre-determined knowledge of where the image base would be,
585 making it impractical for use in intermediate object files
586 */
587 } else {
588 addr -= add_reloc(s, section, 0, size, addr); // X86_64_RELOC_UNSIGNED
589 }
590 } else {
591 error(ERR_NONFATAL, "Mach-O format does not support"
592 " this use of WRT");
593 }
594 }
595 }
596
597 p = mydata;
598 WRITEADDR(p, addr, size);
599 sect_write(s, mydata, size);
600 break;
601
602 case OUT_REL2ADR:
603 p = mydata;
604 WRITESHORT(p, *(int64_t *)data);
605
606 if (section == secto)
607 error(ERR_PANIC, "intra-section OUT_REL2ADR");
608
609 if (section == NO_SEG) {
610 /* Do nothing */
611 } else if (section % 2) {
612 error(ERR_NONFATAL, "Mach-O format does not support"
613 " section base references");
614 } else {
615 error(ERR_NONFATAL, "Unsupported non-32-bit"
616 " Macho-O relocation [2]");
617 }
618
619 sect_write(s, mydata, 2L);
620 break;
621
622 case OUT_REL4ADR:
623 p = mydata;
624 WRITELONG(p, *(int64_t *)data);
625
626 if (section == secto)
627 error(ERR_PANIC, "intra-section OUT_REL4ADR");
628
629 if (section != NO_SEG && section % 2) {
630 error(ERR_NONFATAL, "Mach-O format does not support"
631 " section base references");
632 } else {
633 if (wrt == NO_SEG) {
634 *mydata -= add_reloc(s, section, 1, 4, (int64_t)*mydata); // X86_64_RELOC_SIGNED/BRANCH
635 } else if (wrt == macho_gotpcrel_sect) {
636 if (s->data->datalen > 1) {
637 saa_fread(s->data, s->data->datalen-2, &gotload, 1); // Retrieve Instruction Opcode
638 } else {
639 gotload = 0;
640 }
641 if (gotload == 0x8B) { // Check for MOVQ Opcode
642 *mydata -= add_reloc(s, section, 4, 4, (int64_t)*mydata); // X86_64_GOT_LOAD (MOVQ load)
643 } else {
644 *mydata -= add_reloc(s, section, 3, 4, (int64_t)*mydata); // X86_64_GOT
645 }
646 } else {
647 error(ERR_NONFATAL, "Mach-O format does not support"
648 " this use of WRT");
649 wrt = NO_SEG; /* we can at least _try_ to continue */
650 }
651 }
652
653 sect_write(s, mydata, 4L);
654 break;
655
656 default:
657 error(ERR_PANIC, "unknown output type?");
658 break;
659 }
660 }
661
662 static int32_t macho_section(char *name, int pass, int *bits)
663 {
664 int32_t index, originalIndex;
665 char *sectionAttributes;
666 struct sectmap *sm;
667 struct section *s;
668
669 (void)pass;
670
671 /* Default to 64 bits. */
672 if (!name) {
673 *bits = 64;
674 name = ".text";
675 sectionAttributes = NULL;
676 } else {
677 sectionAttributes = name;
678 name = nasm_strsep(&sectionAttributes, " \t");
679 }
680
681 for (sm = sectmap; sm->nasmsect != NULL; ++sm) {
682 /* make lookup into section name translation table */
683 if (!strcmp(name, sm->nasmsect)) {
684 char *currentAttribute;
685
686 /* try to find section with that name */
687 originalIndex = index = get_section_index_by_name(sm->segname,
688 sm->sectname);
689
690 /* create it if it doesn't exist yet */
691 if (index == -1) {
692 s = *sectstail = nasm_malloc(sizeof(struct section));
693 s->next = NULL;
694 sectstail = &s->next;
695
696 s->data = saa_init(1L);
697 s->index = seg_alloc();
698 s->relocs = NULL;
699 s->align = -1;
700
701 xstrncpy(s->segname, sm->segname);
702 xstrncpy(s->sectname, sm->sectname);
703 s->size = 0;
704 s->nreloc = 0;
705 s->flags = sm->flags;
706
707 index = s->index;
708 } else {
709 s = get_section_by_index(index);
710 }
711
712 while ((NULL != sectionAttributes)
713 && (currentAttribute = nasm_strsep(&sectionAttributes, " \t"))) {
714 if (0 != *currentAttribute) {
715 if (!nasm_strnicmp("align=", currentAttribute, 6)) {
716 char *end;
717 int newAlignment, value;
718
719 value = strtoul(currentAttribute + 6, (char**)&end, 0);
720 newAlignment = exact_log2(value);
721
722 if (0 != *end) {
723 error(ERR_PANIC,
724 "unknown or missing alignment value \"%s\" "
725 "specified for section \"%s\"",
726 currentAttribute + 6,
727 name);
728 return NO_SEG;
729 } else if (0 > newAlignment) {
730 error(ERR_PANIC,
731 "alignment of %d (for section \"%s\") is not "
732 "a power of two",
733 value,
734 name);
735 return NO_SEG;
736 }
737
738 if ((-1 != originalIndex)
739 && (s->align != newAlignment)
740 && (s->align != -1)) {
741 error(ERR_PANIC,
742 "section \"%s\" has already been specified "
743 "with alignment %d, conflicts with new "
744 "alignment of %d",
745 name,
746 (1 << s->align),
747 value);
748 return NO_SEG;
749 }
750
751 s->align = newAlignment;
752 } else if (!nasm_stricmp("data", currentAttribute)) {
753 /* Do nothing; 'data' is implicit */
754 } else {
755 error(ERR_PANIC,
756 "unknown section attribute %s for section %s",
757 currentAttribute,
758 name);
759 return NO_SEG;
760 }
761 }
762 }
763
764 return index;
765 }
766 }
767
768 error(ERR_PANIC, "invalid section name %s", name);
769 return NO_SEG;
770 }
771
772 static void macho_symdef(char *name, int32_t section, int64_t offset,
773 int is_global, char *special)
774 {
775 struct symbol *sym;
776
777 if (special) {
778 error(ERR_NONFATAL, "The Mach-O output format does "
779 "not support any special symbol types");
780 return;
781 }
782
783 if (is_global == 3) {
784 error(ERR_NONFATAL, "The Mach-O format does not "
785 "(yet) support forward reference fixups.");
786 return;
787 }
788
789 if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
790 /*
791 * This is a NASM special symbol. We never allow it into
792 * the Macho-O symbol table, even if it's a valid one. If it
793 * _isn't_ a valid one, we should barf immediately.
794 */
795 if (strcmp(name, "..gotpcrel"))
796 error(ERR_NONFATAL, "unrecognized special symbol `%s'", name);
797 return;
798 }
799
800 sym = *symstail = nasm_malloc(sizeof(struct symbol));
801 sym->next = NULL;
802 symstail = &sym->next;
803
804 sym->name = name;
805 sym->strx = strslen;
806 sym->type = 0;
807 sym->desc = 0;
808 sym->value = offset;
809 sym->initial_snum = -1;
810
811 /* external and common symbols get N_EXT */
812 if (is_global != 0) {
813 sym->type |= N_EXT;
814 }
815
816 if (section == NO_SEG) {
817 /* symbols in no section get absolute */
818 sym->type |= N_ABS;
819 sym->sect = NO_SECT;
820 } else {
821 sym->type |= N_SECT;
822
823 /* get the in-file index of the section the symbol was defined in */
824 sym->sect = get_section_fileindex_by_index(section);
825
826 /* track the initially allocated symbol number for use in future fix-ups */
827 sym->initial_snum = nsyms;
828
829 if (sym->sect == NO_SECT) {
830
831 /* remember symbol number of references to external
832 ** symbols, this works because every external symbol gets
833 ** its own section number allocated internally by nasm and
834 ** can so be used as a key */
835 extsyms = raa_write(extsyms, section, nsyms);
836
837 switch (is_global) {
838 case 1:
839 case 2:
840 /* there isn't actually a difference between global
841 ** and common symbols, both even have their size in
842 ** sym->value */
843 sym->type = N_EXT;
844 break;
845
846 default:
847 /* give an error on unfound section if it's not an
848 ** external or common symbol (assemble_file() does a
849 ** seg_alloc() on every call for them) */
850 error(ERR_PANIC, "in-file index for section %d not found",
851 section);
852 }
853 }
854 }
855 ++nsyms;
856 }
857
858 static int32_t macho_segbase(int32_t section)
859 {
860 return section;
861 }
862
863 static void macho_filename(char *inname, char *outname, efunc error)
864 {
865 standard_extension(inname, outname, ".o", error);
866 }
867
868 extern macros_t macho_stdmac[];
869
870 /* Comparison function for qsort symbol layout. */
871 static int layout_compare (const struct symbol **s1,
872 const struct symbol **s2)
873 {
874 return (strcmp ((*s1)->name, (*s2)->name));
875 }
876
877 /* The native assembler does a few things in a similar function
878
879 * Remove temporary labels
880 * Sort symbols according to local, external, undefined (by name)
881 * Order the string table
882
883 We do not remove temporary labels right now.
884
885 numsyms is the total number of symbols we have. strtabsize is the
886 number entries in the string table. */
887
888 static void macho_layout_symbols (uint32_t *numsyms,
889 uint32_t *strtabsize)
890 {
891 struct symbol *sym, **symp;
892 uint32_t i,j;
893
894 *numsyms = 0;
895 *strtabsize = sizeof (char);
896
897 symp = &syms;
898
899 while ((sym = *symp)) {
900 /* Undefined symbols are now external. */
901 if (sym->type == N_UNDF)
902 sym->type |= N_EXT;
903
904 if ((sym->type & N_EXT) == 0) {
905 sym->snum = *numsyms;
906 *numsyms = *numsyms + 1;
907 nlocalsym++;
908 }
909 else {
910 if ((sym->type & N_TYPE) != N_UNDF) {
911 nextdefsym++;
912 } else {
913 nundefsym++;
914 }
915
916 /* If we handle debug info we'll want
917 to check for it here instead of just
918 adding the symbol to the string table. */
919 sym->strx = *strtabsize;
920 saa_wbytes (strs, sym->name, (int32_t)(strlen(sym->name) + 1));
921 *strtabsize += strlen(sym->name) + 1;
922 }
923 symp = &(sym->next);
924 }
925
926 /* Next, sort the symbols. Most of this code is a direct translation from
927 the Apple cctools symbol layout. We need to keep compatibility with that. */
928 /* Set the indexes for symbol groups into the symbol table */
929 ilocalsym = 0;
930 iextdefsym = nlocalsym;
931 iundefsym = nlocalsym + nextdefsym;
932
933 /* allocate arrays for sorting externals by name */
934 extdefsyms = nasm_malloc(nextdefsym * sizeof(struct symbol *));
935 undefsyms = nasm_malloc(nundefsym * sizeof(struct symbol *));
936
937 i = 0;
938 j = 0;
939
940 symp = &syms;
941
942 while ((sym = *symp)) {
943
944 if((sym->type & N_EXT) == 0) {
945 sym->strx = *strtabsize;
946 saa_wbytes (strs, sym->name, (int32_t)(strlen (sym->name) + 1));
947 *strtabsize += strlen(sym->name) + 1;
948 }
949 else {
950 if((sym->type & N_TYPE) != N_UNDF) {
951 extdefsyms[i++] = sym;
952 } else {
953 undefsyms[j++] = sym;
954 }
955 }
956 symp = &(sym->next);
957 }
958
959 qsort(extdefsyms, nextdefsym, sizeof(struct symbol *),
960 (int (*)(const void *, const void *))layout_compare);
961 qsort(undefsyms, nundefsym, sizeof(struct symbol *),
962 (int (*)(const void *, const void *))layout_compare);
963
964 for(i = 0; i < nextdefsym; i++) {
965 extdefsyms[i]->snum = *numsyms;
966 *numsyms += 1;
967 }
968 for(j = 0; j < nundefsym; j++) {
969 undefsyms[j]->snum = *numsyms;
970 *numsyms += 1;
971 }
972 }
973
974 /* Calculate some values we'll need for writing later. */
975
976 static void macho_calculate_sizes (void)
977 {
978 struct section *s;
979
980 /* count sections and calculate in-memory and in-file offsets */
981 for (s = sects; s != NULL; s = s->next) {
982 uint64_t pad = 0;
983
984 /* zerofill sections aren't actually written to the file */
985 if ((s->flags & SECTION_TYPE) != S_ZEROFILL)
986 seg_filesize64 += s->size;
987
988 /* recalculate segment address based on alignment and vm size */
989 s->addr = seg_vmsize64;
990 /* we need section alignment to calculate final section address */
991 if (s->align == -1)
992 s->align = DEFAULT_SECTION_ALIGNMENT;
993 if(s->align) {
994 uint64_t newaddr = align(s->addr, 1 << s->align);
995 pad = newaddr - s->addr;
996 s->addr = newaddr;
997 }
998
999 seg_vmsize64 += s->size + pad;
1000 ++seg_nsects64;
1001 }
1002
1003 /* calculate size of all headers, load commands and sections to
1004 ** get a pointer to the start of all the raw data */
1005 if (seg_nsects64 > 0) {
1006 ++head_ncmds64;
1007 head_sizeofcmds64 +=
1008 MACHO_SEGCMD64_SIZE + seg_nsects64 * MACHO_SECTCMD64_SIZE;
1009 }
1010
1011 if (nsyms > 0) {
1012 ++head_ncmds64;
1013 head_sizeofcmds64 += MACHO_SYMCMD_SIZE;
1014 }
1015 }
1016
1017 /* Write out the header information for the file. */
1018
1019 static void macho_write_header (void)
1020 {
1021 fwriteint32_t(MH_MAGIC_64, machofp); /* magic */
1022 fwriteint32_t(CPU_TYPE_X86_64, machofp); /* CPU type */
1023 fwriteint32_t(CPU_SUBTYPE_I386_ALL, machofp); /* CPU subtype */
1024 fwriteint32_t(MH_OBJECT, machofp); /* Mach-O file type */
1025 fwriteint32_t(head_ncmds64, machofp); /* number of load commands */
1026 fwriteint32_t(head_sizeofcmds64, machofp); /* size of load commands */
1027 fwriteint32_t(0, machofp); /* no flags */
1028 fwriteint32_t(0, machofp); /* reserved for future use */
1029 }
1030
1031 /* Write out the segment load command at offset. */
1032
1033 static uint32_t macho_write_segment (uint64_t offset)
1034 {
1035 uint64_t rel_base = alignint64_t (offset + seg_filesize64);
1036 uint32_t s_reloff = 0;
1037 struct section *s;
1038
1039 fwriteint32_t(LC_SEGMENT_64, machofp); /* cmd == LC_SEGMENT_64 */
1040
1041 /* size of load command including section load commands */
1042 fwriteint32_t(MACHO_SEGCMD64_SIZE + seg_nsects64 *
1043 MACHO_SECTCMD64_SIZE, machofp);
1044
1045 /* in an MH_OBJECT file all sections are in one unnamed (name
1046 ** all zeros) segment */
1047 fwritezero(16, machofp);
1048 fwriteint64_t(0, machofp); /* in-memory offset */
1049 fwriteint64_t(seg_vmsize64, machofp); /* in-memory size */
1050 fwriteint64_t(offset, machofp); /* in-file offset to data */
1051 fwriteint64_t(seg_filesize64, machofp); /* in-file size */
1052 fwriteint32_t(VM_PROT_DEFAULT, machofp); /* maximum vm protection */
1053 fwriteint32_t(VM_PROT_DEFAULT, machofp); /* initial vm protection */
1054 fwriteint32_t(seg_nsects64, machofp); /* number of sections */
1055 fwriteint32_t(0, machofp); /* no flags */
1056
1057 /* emit section headers */
1058 for (s = sects; s != NULL; s = s->next) {
1059 fwrite(s->sectname, sizeof(s->sectname), 1, machofp);
1060 fwrite(s->segname, sizeof(s->segname), 1, machofp);
1061 fwriteint64_t(s->addr, machofp);
1062 fwriteint64_t(s->size, machofp);
1063
1064 /* dummy data for zerofill sections or proper values */
1065 if ((s->flags & SECTION_TYPE) != S_ZEROFILL) {
1066 fwriteint32_t(offset, machofp);
1067 /* Write out section alignment, as a power of two.
1068 e.g. 32-bit word alignment would be 2 (2^2 = 4). */
1069 if (s->align == -1)
1070 s->align = DEFAULT_SECTION_ALIGNMENT;
1071 fwriteint32_t(s->align, machofp);
1072 /* To be compatible with cctools as we emit
1073 a zero reloff if we have no relocations. */
1074 fwriteint32_t(s->nreloc ? rel_base + s_reloff : 0, machofp);
1075 fwriteint32_t(s->nreloc, machofp);
1076
1077 offset += s->size;
1078 s_reloff += s->nreloc * MACHO_RELINFO64_SIZE;
1079 } else {
1080 fwriteint32_t(0, machofp);
1081 fwriteint32_t(0, machofp);
1082 fwriteint32_t(0, machofp);
1083 fwriteint32_t(0, machofp);
1084 }
1085
1086 if (s->nreloc) {
1087 s->flags |= S_ATTR_LOC_RELOC;
1088 if (s->extreloc)
1089 s->flags |= S_ATTR_EXT_RELOC;
1090 }
1091
1092 fwriteint32_t(s->flags, machofp); /* flags */
1093 fwriteint32_t(0, machofp); /* reserved */
1094 fwriteint32_t(0, machofp); /* reserved */
1095
1096 fwriteint32_t(0, machofp); /* align */
1097 }
1098
1099 rel_padcnt64 = rel_base - offset;
1100 offset = rel_base + s_reloff;
1101
1102 return offset;
1103 }
1104
1105 /* For a given chain of relocs r, write out the entire relocation
1106 chain to the object file. */
1107
1108 static void macho_write_relocs (struct reloc *r)
1109 {
1110 while (r) {
1111 uint32_t word2;
1112
1113 fwriteint32_t(r->addr, machofp); /* reloc offset */
1114
1115 word2 = r->snum;
1116 word2 |= r->pcrel << 24;
1117 word2 |= r->length << 25;
1118 word2 |= r->ext << 27;
1119 word2 |= r->type << 28;
1120 fwriteint32_t(word2, machofp); /* reloc data */
1121 r = r->next;
1122 }
1123 }
1124
1125 /* Write out the section data. */
1126 static void macho_write_section (void)
1127 {
1128 struct section *s, *s2;
1129 struct reloc *r;
1130 uint8_t fi, *p, *q, blk[8];
1131 int32_t len;
1132 int64_t l;
1133
1134 for (s = sects; s != NULL; s = s->next) {
1135 if ((s->flags & SECTION_TYPE) == S_ZEROFILL)
1136 continue;
1137
1138 /* no padding needs to be done to the sections */
1139
1140 /* Like a.out Mach-O references things in the data or bss
1141 * sections by addresses which are actually relative to the
1142 * start of the _text_ section, in the _file_. See outaout.c
1143 * for more information. */
1144 saa_rewind(s->data);
1145 for (r = s->relocs; r != NULL; r = r->next) {
1146 len = (int32_t)r->length << 1;
1147 if(len > 4) len = 8;
1148 saa_fread(s->data, r->addr, blk, len);
1149 p = q = blk;
1150 l = *p++;
1151
1152 /* get offset based on relocation type */
1153 if (r->length > 0) {
1154 l += ((int64_t)*p++) << 8;
1155
1156 if (r->length > 1) {
1157 l += ((int64_t)*p++) << 16;
1158 l += ((int64_t)*p++) << 24;
1159 }
1160
1161 if (r->length > 2) {
1162 l += ((int64_t)*p++) << 32;
1163 l += ((int64_t)*p++) << 40;
1164 l += ((int64_t)*p++) << 48;
1165 l += ((int64_t)*p++) << 56;
1166 }
1167
1168
1169 }
1170
1171 /* If the relocation is internal add to the current section
1172 offset. Otherwise the only value we need is the symbol
1173 offset which we already have. The linker takes care
1174 of the rest of the address. */
1175 if (!r->ext) {
1176 /* generate final address by section address and offset */
1177 for (s2 = sects, fi = 1;
1178 s2 != NULL; s2 = s2->next, fi++) {
1179 if (fi == r->snum) {
1180 l += s2->addr;
1181 break;
1182 }
1183 }
1184 }
1185
1186 /* write new offset back */
1187 if (r->length == 3)
1188 WRITEDLONG(q, l);
1189 else if (r->length == 2)
1190 WRITELONG(q, l);
1191 else if (r->length == 1)
1192 WRITESHORT(q, l);
1193 else
1194 *q++ = l & 0xFF;
1195
1196 saa_fwrite(s->data, r->addr, blk, len);
1197 }
1198
1199 /* dump the section data to file */
1200 saa_fpwrite(s->data, machofp);
1201 }
1202
1203 /* pad last section up to reloc entries on int64_t boundary */
1204 fwritezero(rel_padcnt64, machofp);
1205
1206 /* emit relocation entries */
1207 for (s = sects; s != NULL; s = s->next)
1208 macho_write_relocs (s->relocs);
1209 }
1210
1211 /* Write out the symbol table. We should already have sorted this
1212 before now. */
1213 static void macho_write_symtab (void)
1214 {
1215 struct symbol *sym;
1216 struct section *s;
1217 int64_t fi;
1218 uint64_t i;
1219
1220 /* we don't need to pad here since MACHO_RELINFO_SIZE == 8 */
1221
1222 for (sym = syms; sym != NULL; sym = sym->next) {
1223 if ((sym->type & N_EXT) == 0) {
1224 fwriteint32_t(sym->strx, machofp); /* string table entry number */
1225 fwrite(&sym->type, 1, 1, machofp); /* symbol type */
1226 fwrite(&sym->sect, 1, 1, machofp); /* section */
1227 fwriteint16_t(sym->desc, machofp); /* description */
1228
1229 /* Fix up the symbol value now that we know the final section
1230 sizes. */
1231 if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
1232 for (s = sects, fi = 1;
1233 s != NULL && fi < sym->sect; s = s->next, ++fi)
1234 sym->value += s->size;
1235 }
1236
1237 fwriteint64_t(sym->value, machofp); /* value (i.e. offset) */
1238 }
1239 }
1240
1241 for (i = 0; i < nextdefsym; i++) {
1242 sym = extdefsyms[i];
1243 fwriteint32_t(sym->strx, machofp);
1244 fwrite(&sym->type, 1, 1, machofp); /* symbol type */
1245 fwrite(&sym->sect, 1, 1, machofp); /* section */
1246 fwriteint16_t(sym->desc, machofp); /* description */
1247
1248 /* Fix up the symbol value now that we know the final section
1249 sizes. */
1250 if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
1251 for (s = sects, fi = 1;
1252 s != NULL && fi < sym->sect; s = s->next, ++fi)
1253 sym->value += s->size;
1254 }
1255
1256 fwriteint64_t(sym->value, machofp); /* value (i.e. offset) */
1257 }
1258
1259 for (i = 0; i < nundefsym; i++) {
1260 sym = undefsyms[i];
1261 fwriteint32_t(sym->strx, machofp);
1262 fwrite(&sym->type, 1, 1, machofp); /* symbol type */
1263 fwrite(&sym->sect, 1, 1, machofp); /* section */
1264 fwriteint16_t(sym->desc, machofp); /* description */
1265
1266 // Fix up the symbol value now that we know the final section sizes.
1267 if (((sym->type & N_TYPE) == N_SECT) && (sym->sect != NO_SECT)) {
1268 for (s = sects, fi = 1;
1269 s != NULL && fi < sym->sect; s = s->next, ++fi)
1270 sym->value += s->size;
1271 }
1272
1273 fwriteint64_t(sym->value, machofp); // value (i.e. offset)
1274 }
1275
1276 }
1277
1278 /* Fixup the snum in the relocation entries, we should be
1279 doing this only for externally referenced symbols. */
1280 static void macho_fixup_relocs (struct reloc *r)
1281 {
1282 struct symbol *sym;
1283
1284 while (r != NULL) {
1285 if (r->ext) {
1286 for (sym = syms; sym != NULL; sym = sym->next) {
1287 if (sym->initial_snum == r->snum) {
1288 r->snum = sym->snum;
1289 break;
1290 }
1291 }
1292 }
1293 r = r->next;
1294 }
1295 }
1296
1297 /* Write out the object file. */
1298
1299 static void macho_write (void)
1300 {
1301 uint64_t offset = 0;
1302
1303 /* mach-o object file structure:
1304 **
1305 ** mach header
1306 ** uint32_t magic
1307 ** int cpu type
1308 ** int cpu subtype
1309 ** uint32_t mach file type
1310 ** uint32_t number of load commands
1311 ** uint32_t size of all load commands
1312 ** (includes section struct size of segment command)
1313 ** uint32_t flags
1314 **
1315 ** segment command
1316 ** uint32_t command type == LC_SEGMENT_64
1317 ** uint32_t size of load command
1318 ** (including section load commands)
1319 ** char[16] segment name
1320 ** uint64_t in-memory offset
1321 ** uint64_t in-memory size
1322 ** uint64_t in-file offset to data area
1323 ** uint64_t in-file size
1324 ** (in-memory size excluding zerofill sections)
1325 ** int maximum vm protection
1326 ** int initial vm protection
1327 ** uint32_t number of sections
1328 ** uint32_t flags
1329 **
1330 ** section commands
1331 ** char[16] section name
1332 ** char[16] segment name
1333 ** uint64_t in-memory offset
1334 ** uint64_t in-memory size
1335 ** uint32_t in-file offset
1336 ** uint32_t alignment
1337 ** (irrelevant in MH_OBJECT)
1338 ** uint32_t in-file offset of relocation entires
1339 ** uint32_t number of relocations
1340 ** uint32_t flags
1341 ** uint32_t reserved
1342 ** uint32_t reserved
1343 **
1344 ** symbol table command
1345 ** uint32_t command type == LC_SYMTAB
1346 ** uint32_t size of load command
1347 ** uint32_t symbol table offset
1348 ** uint32_t number of symbol table entries
1349 ** uint32_t string table offset
1350 ** uint32_t string table size
1351 **
1352 ** raw section data
1353 **
1354 ** padding to int64_t boundary
1355 **
1356 ** relocation data (struct reloc)
1357 ** int32_t offset
1358 ** uint data (symbolnum, pcrel, length, extern, type)
1359 **
1360 ** symbol table data (struct nlist)
1361 ** int32_t string table entry number
1362 ** uint8_t type
1363 ** (extern, absolute, defined in section)
1364 ** uint8_t section
1365 ** (0 for global symbols, section number of definition (>= 1, <=
1366 ** 254) for local symbols, size of variable for common symbols
1367 ** [type == extern])
1368 ** int16_t description
1369 ** (for stab debugging format)
1370 ** uint64_t value (i.e. file offset) of symbol or stab offset
1371 **
1372 ** string table data
1373 ** list of null-terminated strings
1374 */
1375
1376 /* Emit the Mach-O header. */
1377 macho_write_header();
1378
1379 offset = MACHO_HEADER64_SIZE + head_sizeofcmds64;
1380
1381 /* emit the segment load command */
1382 if (seg_nsects64 > 0)
1383 offset = macho_write_segment (offset);
1384 else
1385 error(ERR_WARNING, "no sections?");
1386
1387 if (nsyms > 0) {
1388 /* write out symbol command */
1389 fwriteint32_t(LC_SYMTAB, machofp); /* cmd == LC_SYMTAB */
1390 fwriteint32_t(MACHO_SYMCMD_SIZE, machofp); /* size of load command */
1391 fwriteint32_t(offset, machofp); /* symbol table offset */
1392 fwriteint32_t(nsyms, machofp); /* number of symbol
1393 ** table entries */
1394
1395 offset += nsyms * MACHO_NLIST64_SIZE;
1396 fwriteint32_t(offset, machofp); /* string table offset */
1397 fwriteint32_t(strslen, machofp); /* string table size */
1398 }
1399
1400 /* emit section data */
1401 if (seg_nsects64 > 0)
1402 macho_write_section ();
1403
1404 /* emit symbol table if we have symbols */
1405 if (nsyms > 0)
1406 macho_write_symtab ();
1407
1408 /* we don't need to pad here since MACHO_NLIST64_SIZE == 16 */
1409
1410 /* emit string table */
1411 saa_fpwrite(strs, machofp);
1412 }
1413 /* We do quite a bit here, starting with finalizing all of the data
1414 for the object file, writing, and then freeing all of the data from
1415 the file. */
1416
1417 static void macho_cleanup(int debuginfo)
1418 {
1419 struct section *s;
1420 struct reloc *r;
1421 struct symbol *sym;
1422
1423 (void)debuginfo;
1424
1425 /* Sort all symbols. */
1426 macho_layout_symbols (&nsyms, &strslen);
1427
1428 /* Fixup relocation entries */
1429 for (s = sects; s != NULL; s = s->next) {
1430 macho_fixup_relocs (s->relocs);
1431 }
1432
1433 /* First calculate and finalize needed values. */
1434 macho_calculate_sizes();
1435 macho_write();
1436
1437 /* free up everything */
1438 while (sects->next) {
1439 s = sects;
1440 sects = sects->next;
1441
1442 saa_free(s->data);
1443 while (s->relocs != NULL) {
1444 r = s->relocs;
1445 s->relocs = s->relocs->next;
1446 nasm_free(r);
1447 }
1448
1449 nasm_free(s);
1450 }
1451
1452 saa_free(strs);
1453 raa_free(extsyms);
1454
1455 if (syms) {
1456 while (syms->next) {
1457 sym = syms;
1458 syms = syms->next;
1459
1460 nasm_free (sym);
1461 }
1462 }
1463 }
1464
1465 /* Debugging routines. */
1466 static void debug_reloc (struct reloc *r)
1467 {
1468 fprintf (stdout, "reloc:\n");
1469 fprintf (stdout, "\taddr: %"PRId32"\n", r->addr);
1470 fprintf (stdout, "\tsnum: %d\n", r->snum);
1471 fprintf (stdout, "\tpcrel: %d\n", r->pcrel);
1472 fprintf (stdout, "\tlength: %d\n", r->length);
1473 fprintf (stdout, "\text: %d\n", r->ext);
1474 fprintf (stdout, "\ttype: %d\n", r->type);
1475 }
1476
1477 static void debug_section_relocs (struct section *s)
1478 {
1479 struct reloc *r = s->relocs;
1480
1481 fprintf (stdout, "relocs for section %s:\n\n", s->sectname);
1482
1483 while (r != NULL) {
1484 debug_reloc (r);
1485 r = r->next;
1486 }
1487 }
1488
1489 struct ofmt of_macho64 = {
1490 "NeXTstep/OpenStep/Rhapsody/Darwin/MacOS X (x86_64) object files",
1491 "macho64",
1492 0,
1493 null_debug_arr,
1494 &null_debug_form,
1495 macho_stdmac,
1496 macho_init,
1497 null_setinfo,
1498 macho_output,
1499 macho_symdef,
1500 macho_section,
1501 macho_segbase,
1502 null_directive,
1503 macho_filename,
1504 macho_cleanup
1505 };
1506
1507 #endif
1508
1509 /*
1510 * Local Variables:
1511 * mode:c
1512 * c-basic-offset:4
1513 * End:
1514 *
1515 * end of file */
The Netwide Assembler