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