?  search:
summary | log | graphiclog1 | graphiclog2 | refs | edit | fork

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