(c-guess-basic-syntax): Move CASE 19 to a different place, correctly to
[emacs.git] / src / unexmacosx.c
blob7a55498085dbd2719e4bdfc1ef59766afca4bc1c
1 /* Dump Emacs in Mach-O format for use on Mac OS X.
2 Copyright (C) 2001-2011 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
19 /* Contributed by Andrew Choi (akochoi@mac.com). */
21 /* Documentation note.
23 Consult the following documents/files for a description of the
24 Mach-O format: the file loader.h, man pages for Mach-O and ld, old
25 NEXTSTEP documents of the Mach-O format. The tool otool dumps the
26 mach header (-h option) and the load commands (-l option) in a
27 Mach-O file. The tool nm on Mac OS X displays the symbol table in
28 a Mach-O file. For examples of unexec for the Mach-O format, see
29 the file unexnext.c in the GNU Emacs distribution, the file
30 unexdyld.c in the Darwin port of GNU Emacs 20.7, and unexdyld.c in
31 the Darwin port of XEmacs 21.1. Also the Darwin Libc source
32 contains the source code for malloc_freezedry and malloc_jumpstart.
33 Read that to see what they do. This file was written completely
34 from scratch, making use of information from the above sources. */
36 /* The Mac OS X implementation of unexec makes use of Darwin's `zone'
37 memory allocator. All calls to malloc, realloc, and free in Emacs
38 are redirected to unexec_malloc, unexec_realloc, and unexec_free in
39 this file. When temacs is run, all memory requests are handled in
40 the zone EmacsZone. The Darwin memory allocator library calls
41 maintain the data structures to manage this zone. Dumping writes
42 its contents to data segments of the executable file. When emacs
43 is run, the loader recreates the contents of the zone in memory.
44 However since the initialization routine of the zone memory
45 allocator is run again, this `zone' can no longer be used as a
46 heap. That is why emacs uses the ordinary malloc system call to
47 allocate memory. Also, when a block of memory needs to be
48 reallocated and the new size is larger than the old one, a new
49 block must be obtained by malloc and the old contents copied to
50 it. */
52 /* Peculiarity of the Mach-O files generated by ld in Mac OS X
53 (possible causes of future bugs if changed).
55 The file offset of the start of the __TEXT segment is zero. Since
56 the Mach header and load commands are located at the beginning of a
57 Mach-O file, copying the contents of the __TEXT segment from the
58 input file overwrites them in the output file. Despite this,
59 unexec works fine as written below because the segment load command
60 for __TEXT appears, and is therefore processed, before all other
61 load commands except the segment load command for __PAGEZERO, which
62 remains unchanged.
64 Although the file offset of the start of the __TEXT segment is
65 zero, none of the sections it contains actually start there. In
66 fact, the earliest one starts a few hundred bytes beyond the end of
67 the last load command. The linker option -headerpad controls the
68 minimum size of this padding. Its setting can be changed in
69 s/darwin.h. A value of 0x690, e.g., leaves room for 30 additional
70 load commands for the newly created __DATA segments (at 56 bytes
71 each). Unexec fails if there is not enough room for these new
72 segments.
74 The __TEXT segment contains the sections __text, __cstring,
75 __picsymbol_stub, and __const and the __DATA segment contains the
76 sections __data, __la_symbol_ptr, __nl_symbol_ptr, __dyld, __bss,
77 and __common. The other segments do not contain any sections.
78 These sections are copied from the input file to the output file,
79 except for __data, __bss, and __common, which are dumped from
80 memory. The types of the sections __bss and __common are changed
81 from S_ZEROFILL to S_REGULAR. Note that the number of sections and
82 their relative order in the input and output files remain
83 unchanged. Otherwise all n_sect fields in the nlist records in the
84 symbol table (specified by the LC_SYMTAB load command) will have to
85 be changed accordingly.
88 /* config.h #define:s malloc/realloc/free and then includes stdlib.h.
89 We want the undefined versions, but if config.h includes stdlib.h
90 with the #define:s in place, the prototypes will be wrong and we get
91 warnings. To prevent that, include stdlib.h before config.h. */
93 #include <stdlib.h>
94 #include <config.h>
95 #undef malloc
96 #undef realloc
97 #undef free
98 #include <stdio.h>
99 #include <fcntl.h>
100 #include <stdarg.h>
101 #include <sys/types.h>
102 #include <unistd.h>
103 #include <mach/mach.h>
104 #include <mach-o/loader.h>
105 #include <mach-o/reloc.h>
106 #if defined (__ppc__)
107 #include <mach-o/ppc/reloc.h>
108 #endif
109 #ifdef HAVE_MALLOC_MALLOC_H
110 #include <malloc/malloc.h>
111 #else
112 #include <objc/malloc.h>
113 #endif
115 #include <assert.h>
117 #ifdef _LP64
118 #define mach_header mach_header_64
119 #define segment_command segment_command_64
120 #undef VM_REGION_BASIC_INFO_COUNT
121 #define VM_REGION_BASIC_INFO_COUNT VM_REGION_BASIC_INFO_COUNT_64
122 #undef VM_REGION_BASIC_INFO
123 #define VM_REGION_BASIC_INFO VM_REGION_BASIC_INFO_64
124 #undef LC_SEGMENT
125 #define LC_SEGMENT LC_SEGMENT_64
126 #define vm_region vm_region_64
127 #define section section_64
128 #undef MH_MAGIC
129 #define MH_MAGIC MH_MAGIC_64
130 #endif
132 #define VERBOSE 1
134 /* Size of buffer used to copy data from the input file to the output
135 file in function unexec_copy. */
136 #define UNEXEC_COPY_BUFSZ 1024
138 /* Regions with memory addresses above this value are assumed to be
139 mapped to dynamically loaded libraries and will not be dumped. */
140 #define VM_DATA_TOP (20 * 1024 * 1024)
142 /* Type of an element on the list of regions to be dumped. */
143 struct region_t {
144 vm_address_t address;
145 vm_size_t size;
146 vm_prot_t protection;
147 vm_prot_t max_protection;
149 struct region_t *next;
152 /* Head and tail of the list of regions to be dumped. */
153 static struct region_t *region_list_head = 0;
154 static struct region_t *region_list_tail = 0;
156 /* Pointer to array of load commands. */
157 static struct load_command **lca;
159 /* Number of load commands. */
160 static int nlc;
162 /* The highest VM address of segments loaded by the input file.
163 Regions with addresses beyond this are assumed to be allocated
164 dynamically and thus require dumping. */
165 static vm_address_t infile_lc_highest_addr = 0;
167 /* The lowest file offset used by the all sections in the __TEXT
168 segments. This leaves room at the beginning of the file to store
169 the Mach-O header. Check this value against header size to ensure
170 the added load commands for the new __DATA segments did not
171 overwrite any of the sections in the __TEXT segment. */
172 static unsigned long text_seg_lowest_offset = 0x10000000;
174 /* Mach header. */
175 static struct mach_header mh;
177 /* Offset at which the next load command should be written. */
178 static unsigned long curr_header_offset = sizeof (struct mach_header);
180 /* Offset at which the next segment should be written. */
181 static unsigned long curr_file_offset = 0;
183 static unsigned long pagesize;
184 #define ROUNDUP_TO_PAGE_BOUNDARY(x) (((x) + pagesize - 1) & ~(pagesize - 1))
186 static int infd, outfd;
188 static int in_dumped_exec = 0;
190 static malloc_zone_t *emacs_zone;
192 /* file offset of input file's data segment */
193 static off_t data_segment_old_fileoff = 0;
195 static struct segment_command *data_segment_scp;
197 static void unexec_error (const char *format, ...) NO_RETURN;
199 /* Read N bytes from infd into memory starting at address DEST.
200 Return true if successful, false otherwise. */
201 static int
202 unexec_read (void *dest, size_t n)
204 return n == read (infd, dest, n);
207 /* Write COUNT bytes from memory starting at address SRC to outfd
208 starting at offset DEST. Return true if successful, false
209 otherwise. */
210 static int
211 unexec_write (off_t dest, const void *src, size_t count)
213 if (lseek (outfd, dest, SEEK_SET) != dest)
214 return 0;
216 return write (outfd, src, count) == count;
219 /* Write COUNT bytes of zeros to outfd starting at offset DEST.
220 Return true if successful, false otherwise. */
221 static int
222 unexec_write_zero (off_t dest, size_t count)
224 char buf[UNEXEC_COPY_BUFSZ];
225 ssize_t bytes;
227 memset (buf, 0, UNEXEC_COPY_BUFSZ);
228 if (lseek (outfd, dest, SEEK_SET) != dest)
229 return 0;
231 while (count > 0)
233 bytes = count > UNEXEC_COPY_BUFSZ ? UNEXEC_COPY_BUFSZ : count;
234 if (write (outfd, buf, bytes) != bytes)
235 return 0;
236 count -= bytes;
239 return 1;
242 /* Copy COUNT bytes from starting offset SRC in infd to starting
243 offset DEST in outfd. Return true if successful, false
244 otherwise. */
245 static int
246 unexec_copy (off_t dest, off_t src, ssize_t count)
248 ssize_t bytes_read;
249 ssize_t bytes_to_read;
251 char buf[UNEXEC_COPY_BUFSZ];
253 if (lseek (infd, src, SEEK_SET) != src)
254 return 0;
256 if (lseek (outfd, dest, SEEK_SET) != dest)
257 return 0;
259 while (count > 0)
261 bytes_to_read = count > UNEXEC_COPY_BUFSZ ? UNEXEC_COPY_BUFSZ : count;
262 bytes_read = read (infd, buf, bytes_to_read);
263 if (bytes_read <= 0)
264 return 0;
265 if (write (outfd, buf, bytes_read) != bytes_read)
266 return 0;
267 count -= bytes_read;
270 return 1;
273 /* Debugging and informational messages routines. */
275 static void
276 unexec_error (const char *format, ...)
278 va_list ap;
280 va_start (ap, format);
281 fprintf (stderr, "unexec: ");
282 vfprintf (stderr, format, ap);
283 fprintf (stderr, "\n");
284 va_end (ap);
285 exit (1);
288 static void
289 print_prot (vm_prot_t prot)
291 if (prot == VM_PROT_NONE)
292 printf ("none");
293 else
295 putchar (prot & VM_PROT_READ ? 'r' : ' ');
296 putchar (prot & VM_PROT_WRITE ? 'w' : ' ');
297 putchar (prot & VM_PROT_EXECUTE ? 'x' : ' ');
298 putchar (' ');
302 static void
303 print_region (vm_address_t address, vm_size_t size, vm_prot_t prot,
304 vm_prot_t max_prot)
306 printf ("%#10lx %#8lx ", (long) address, (long) size);
307 print_prot (prot);
308 putchar (' ');
309 print_prot (max_prot);
310 putchar ('\n');
313 static void
314 print_region_list (void)
316 struct region_t *r;
318 printf (" address size prot maxp\n");
320 for (r = region_list_head; r; r = r->next)
321 print_region (r->address, r->size, r->protection, r->max_protection);
324 static void
325 print_regions (void)
327 task_t target_task = mach_task_self ();
328 vm_address_t address = (vm_address_t) 0;
329 vm_size_t size;
330 struct vm_region_basic_info info;
331 mach_msg_type_number_t info_count = VM_REGION_BASIC_INFO_COUNT;
332 mach_port_t object_name;
334 printf (" address size prot maxp\n");
336 while (vm_region (target_task, &address, &size, VM_REGION_BASIC_INFO,
337 (vm_region_info_t) &info, &info_count, &object_name)
338 == KERN_SUCCESS && info_count == VM_REGION_BASIC_INFO_COUNT)
340 print_region (address, size, info.protection, info.max_protection);
342 if (object_name != MACH_PORT_NULL)
343 mach_port_deallocate (target_task, object_name);
345 address += size;
349 /* Build the list of regions that need to be dumped. Regions with
350 addresses above VM_DATA_TOP are omitted. Adjacent regions with
351 identical protection are merged. Note that non-writable regions
352 cannot be omitted because they some regions created at run time are
353 read-only. */
354 static void
355 build_region_list (void)
357 task_t target_task = mach_task_self ();
358 vm_address_t address = (vm_address_t) 0;
359 vm_size_t size;
360 struct vm_region_basic_info info;
361 mach_msg_type_number_t info_count = VM_REGION_BASIC_INFO_COUNT;
362 mach_port_t object_name;
363 struct region_t *r;
365 #if VERBOSE
366 printf ("--- List of All Regions ---\n");
367 printf (" address size prot maxp\n");
368 #endif
370 while (vm_region (target_task, &address, &size, VM_REGION_BASIC_INFO,
371 (vm_region_info_t) &info, &info_count, &object_name)
372 == KERN_SUCCESS && info_count == VM_REGION_BASIC_INFO_COUNT)
374 /* Done when we reach addresses of shared libraries, which are
375 loaded in high memory. */
376 if (address >= VM_DATA_TOP)
377 break;
379 #if VERBOSE
380 print_region (address, size, info.protection, info.max_protection);
381 #endif
383 /* If a region immediately follows the previous one (the one
384 most recently added to the list) and has identical
385 protection, merge it with the latter. Otherwise create a
386 new list element for it. */
387 if (region_list_tail
388 && info.protection == region_list_tail->protection
389 && info.max_protection == region_list_tail->max_protection
390 && region_list_tail->address + region_list_tail->size == address)
392 region_list_tail->size += size;
394 else
396 r = (struct region_t *) malloc (sizeof (struct region_t));
398 if (!r)
399 unexec_error ("cannot allocate region structure");
401 r->address = address;
402 r->size = size;
403 r->protection = info.protection;
404 r->max_protection = info.max_protection;
406 r->next = 0;
407 if (region_list_head == 0)
409 region_list_head = r;
410 region_list_tail = r;
412 else
414 region_list_tail->next = r;
415 region_list_tail = r;
418 /* Deallocate (unused) object name returned by
419 vm_region. */
420 if (object_name != MACH_PORT_NULL)
421 mach_port_deallocate (target_task, object_name);
424 address += size;
427 printf ("--- List of Regions to be Dumped ---\n");
428 print_region_list ();
432 #define MAX_UNEXEC_REGIONS 400
434 static int num_unexec_regions;
435 typedef struct {
436 vm_range_t range;
437 vm_size_t filesize;
438 } unexec_region_info;
439 static unexec_region_info unexec_regions[MAX_UNEXEC_REGIONS];
441 static void
442 unexec_regions_recorder (task_t task, void *rr, unsigned type,
443 vm_range_t *ranges, unsigned num)
445 vm_address_t p;
446 vm_size_t filesize;
448 while (num && num_unexec_regions < MAX_UNEXEC_REGIONS)
450 /* Subtract the size of trailing null bytes from filesize. It
451 can be smaller than vmsize in segment commands. In such a
452 case, trailing bytes are initialized with zeros. */
453 for (p = ranges->address + ranges->size; p > ranges->address; p--)
454 if (*(((char *) p)-1))
455 break;
456 filesize = p - ranges->address;
458 unexec_regions[num_unexec_regions].filesize = filesize;
459 unexec_regions[num_unexec_regions++].range = *ranges;
460 printf ("%#10lx (sz: %#8lx/%#8lx)\n", (long) (ranges->address),
461 (long) filesize, (long) (ranges->size));
462 ranges++; num--;
466 static kern_return_t
467 unexec_reader (task_t task, vm_address_t address, vm_size_t size, void **ptr)
469 *ptr = (void *) address;
470 return KERN_SUCCESS;
473 static void
474 find_emacs_zone_regions (void)
476 num_unexec_regions = 0;
478 emacs_zone->introspect->enumerator (mach_task_self(), 0,
479 MALLOC_PTR_REGION_RANGE_TYPE
480 | MALLOC_ADMIN_REGION_RANGE_TYPE,
481 (vm_address_t) emacs_zone,
482 unexec_reader,
483 unexec_regions_recorder);
485 if (num_unexec_regions == MAX_UNEXEC_REGIONS)
486 unexec_error ("find_emacs_zone_regions: too many regions");
489 static int
490 unexec_regions_sort_compare (const void *a, const void *b)
492 vm_address_t aa = ((unexec_region_info *) a)->range.address;
493 vm_address_t bb = ((unexec_region_info *) b)->range.address;
495 if (aa < bb)
496 return -1;
497 else if (aa > bb)
498 return 1;
499 else
500 return 0;
503 static void
504 unexec_regions_merge (void)
506 int i, n;
507 unexec_region_info r;
508 vm_size_t padsize;
510 qsort (unexec_regions, num_unexec_regions, sizeof (unexec_regions[0]),
511 &unexec_regions_sort_compare);
512 n = 0;
513 r = unexec_regions[0];
514 padsize = r.range.address & (pagesize - 1);
515 if (padsize)
517 r.range.address -= padsize;
518 r.range.size += padsize;
519 r.filesize += padsize;
521 for (i = 1; i < num_unexec_regions; i++)
523 if (r.range.address + r.range.size == unexec_regions[i].range.address
524 && r.range.size - r.filesize < 2 * pagesize)
526 r.filesize = r.range.size + unexec_regions[i].filesize;
527 r.range.size += unexec_regions[i].range.size;
529 else
531 unexec_regions[n++] = r;
532 r = unexec_regions[i];
533 padsize = r.range.address & (pagesize - 1);
534 if (padsize)
536 if ((unexec_regions[n-1].range.address
537 + unexec_regions[n-1].range.size) == r.range.address)
538 unexec_regions[n-1].range.size -= padsize;
540 r.range.address -= padsize;
541 r.range.size += padsize;
542 r.filesize += padsize;
546 unexec_regions[n++] = r;
547 num_unexec_regions = n;
551 /* More informational messages routines. */
553 static void
554 print_load_command_name (int lc)
556 switch (lc)
558 case LC_SEGMENT:
559 #ifndef _LP64
560 printf ("LC_SEGMENT ");
561 #else
562 printf ("LC_SEGMENT_64 ");
563 #endif
564 break;
565 case LC_LOAD_DYLINKER:
566 printf ("LC_LOAD_DYLINKER ");
567 break;
568 case LC_LOAD_DYLIB:
569 printf ("LC_LOAD_DYLIB ");
570 break;
571 case LC_SYMTAB:
572 printf ("LC_SYMTAB ");
573 break;
574 case LC_DYSYMTAB:
575 printf ("LC_DYSYMTAB ");
576 break;
577 case LC_UNIXTHREAD:
578 printf ("LC_UNIXTHREAD ");
579 break;
580 case LC_PREBOUND_DYLIB:
581 printf ("LC_PREBOUND_DYLIB");
582 break;
583 case LC_TWOLEVEL_HINTS:
584 printf ("LC_TWOLEVEL_HINTS");
585 break;
586 #ifdef LC_UUID
587 case LC_UUID:
588 printf ("LC_UUID ");
589 break;
590 #endif
591 #ifdef LC_DYLD_INFO
592 case LC_DYLD_INFO:
593 printf ("LC_DYLD_INFO ");
594 break;
595 case LC_DYLD_INFO_ONLY:
596 printf ("LC_DYLD_INFO_ONLY");
597 break;
598 #endif
599 default:
600 printf ("unknown ");
604 static void
605 print_load_command (struct load_command *lc)
607 print_load_command_name (lc->cmd);
608 printf ("%8d", lc->cmdsize);
610 if (lc->cmd == LC_SEGMENT)
612 struct segment_command *scp;
613 struct section *sectp;
614 int j;
616 scp = (struct segment_command *) lc;
617 printf (" %-16.16s %#10lx %#8lx\n",
618 scp->segname, (long) (scp->vmaddr), (long) (scp->vmsize));
620 sectp = (struct section *) (scp + 1);
621 for (j = 0; j < scp->nsects; j++)
623 printf (" %-16.16s %#10lx %#8lx\n",
624 sectp->sectname, (long) (sectp->addr), (long) (sectp->size));
625 sectp++;
628 else
629 printf ("\n");
632 /* Read header and load commands from input file. Store the latter in
633 the global array lca. Store the total number of load commands in
634 global variable nlc. */
635 static void
636 read_load_commands (void)
638 int i;
640 if (!unexec_read (&mh, sizeof (struct mach_header)))
641 unexec_error ("cannot read mach-o header");
643 if (mh.magic != MH_MAGIC)
644 unexec_error ("input file not in Mach-O format");
646 if (mh.filetype != MH_EXECUTE)
647 unexec_error ("input Mach-O file is not an executable object file");
649 #if VERBOSE
650 printf ("--- Header Information ---\n");
651 printf ("Magic = 0x%08x\n", mh.magic);
652 printf ("CPUType = %d\n", mh.cputype);
653 printf ("CPUSubType = %d\n", mh.cpusubtype);
654 printf ("FileType = 0x%x\n", mh.filetype);
655 printf ("NCmds = %d\n", mh.ncmds);
656 printf ("SizeOfCmds = %d\n", mh.sizeofcmds);
657 printf ("Flags = 0x%08x\n", mh.flags);
658 #endif
660 nlc = mh.ncmds;
661 lca = (struct load_command **) malloc (nlc * sizeof (struct load_command *));
663 for (i = 0; i < nlc; i++)
665 struct load_command lc;
666 /* Load commands are variable-size: so read the command type and
667 size first and then read the rest. */
668 if (!unexec_read (&lc, sizeof (struct load_command)))
669 unexec_error ("cannot read load command");
670 lca[i] = (struct load_command *) malloc (lc.cmdsize);
671 memcpy (lca[i], &lc, sizeof (struct load_command));
672 if (!unexec_read (lca[i] + 1, lc.cmdsize - sizeof (struct load_command)))
673 unexec_error ("cannot read content of load command");
674 if (lc.cmd == LC_SEGMENT)
676 struct segment_command *scp = (struct segment_command *) lca[i];
678 if (scp->vmaddr + scp->vmsize > infile_lc_highest_addr)
679 infile_lc_highest_addr = scp->vmaddr + scp->vmsize;
681 if (strncmp (scp->segname, SEG_TEXT, 16) == 0)
683 struct section *sectp = (struct section *) (scp + 1);
684 int j;
686 for (j = 0; j < scp->nsects; j++)
687 if (sectp->offset < text_seg_lowest_offset)
688 text_seg_lowest_offset = sectp->offset;
693 printf ("Highest address of load commands in input file: %#8lx\n",
694 (unsigned long)infile_lc_highest_addr);
696 printf ("Lowest offset of all sections in __TEXT segment: %#8lx\n",
697 text_seg_lowest_offset);
699 printf ("--- List of Load Commands in Input File ---\n");
700 printf ("# cmd cmdsize name address size\n");
702 for (i = 0; i < nlc; i++)
704 printf ("%1d ", i);
705 print_load_command (lca[i]);
709 /* Copy a LC_SEGMENT load command other than the __DATA segment from
710 the input file to the output file, adjusting the file offset of the
711 segment and the file offsets of sections contained in it. */
712 static void
713 copy_segment (struct load_command *lc)
715 struct segment_command *scp = (struct segment_command *) lc;
716 unsigned long old_fileoff = scp->fileoff;
717 struct section *sectp;
718 int j;
720 scp->fileoff = curr_file_offset;
722 sectp = (struct section *) (scp + 1);
723 for (j = 0; j < scp->nsects; j++)
725 sectp->offset += curr_file_offset - old_fileoff;
726 sectp++;
729 printf ("Writing segment %-16.16s @ %#8lx (%#8lx/%#8lx @ %#10lx)\n",
730 scp->segname, (long) (scp->fileoff), (long) (scp->filesize),
731 (long) (scp->vmsize), (long) (scp->vmaddr));
733 if (!unexec_copy (scp->fileoff, old_fileoff, scp->filesize))
734 unexec_error ("cannot copy segment from input to output file");
735 curr_file_offset += ROUNDUP_TO_PAGE_BOUNDARY (scp->filesize);
737 if (!unexec_write (curr_header_offset, lc, lc->cmdsize))
738 unexec_error ("cannot write load command to header");
740 curr_header_offset += lc->cmdsize;
743 /* Copy a LC_SEGMENT load command for the __DATA segment in the input
744 file to the output file. We assume that only one such segment load
745 command exists in the input file and it contains the sections
746 __data, __bss, __common, __la_symbol_ptr, __nl_symbol_ptr, and
747 __dyld. The first three of these should be dumped from memory and
748 the rest should be copied from the input file. Note that the
749 sections __bss and __common contain no data in the input file
750 because their flag fields have the value S_ZEROFILL. Dumping these
751 from memory makes it necessary to adjust file offset fields in
752 subsequently dumped load commands. Then, create new __DATA segment
753 load commands for regions on the region list other than the one
754 corresponding to the __DATA segment in the input file. */
755 static void
756 copy_data_segment (struct load_command *lc)
758 struct segment_command *scp = (struct segment_command *) lc;
759 struct section *sectp;
760 int j;
761 unsigned long header_offset, old_file_offset;
763 /* The new filesize of the segment is set to its vmsize because data
764 blocks for segments must start at region boundaries. Note that
765 this may leave unused locations at the end of the segment data
766 block because the total of the sizes of all sections in the
767 segment is generally smaller than vmsize. */
768 scp->filesize = scp->vmsize;
770 printf ("Writing segment %-16.16s @ %#8lx (%#8lx/%#8lx @ %#10lx)\n",
771 scp->segname, curr_file_offset, (long)(scp->filesize),
772 (long)(scp->vmsize), (long) (scp->vmaddr));
774 /* Offsets in the output file for writing the next section structure
775 and segment data block, respectively. */
776 header_offset = curr_header_offset + sizeof (struct segment_command);
778 sectp = (struct section *) (scp + 1);
779 for (j = 0; j < scp->nsects; j++)
781 old_file_offset = sectp->offset;
782 sectp->offset = sectp->addr - scp->vmaddr + curr_file_offset;
783 /* The __data section is dumped from memory. The __bss and
784 __common sections are also dumped from memory but their flag
785 fields require changing (from S_ZEROFILL to S_REGULAR). The
786 other three kinds of sections are just copied from the input
787 file. */
788 if (strncmp (sectp->sectname, SECT_DATA, 16) == 0)
790 if (!unexec_write (sectp->offset, (void *) sectp->addr, sectp->size))
791 unexec_error ("cannot write section %s", SECT_DATA);
792 if (!unexec_write (header_offset, sectp, sizeof (struct section)))
793 unexec_error ("cannot write section %s's header", SECT_DATA);
795 else if (strncmp (sectp->sectname, SECT_COMMON, 16) == 0)
797 sectp->flags = S_REGULAR;
798 if (!unexec_write (sectp->offset, (void *) sectp->addr, sectp->size))
799 unexec_error ("cannot write section %s", sectp->sectname);
800 if (!unexec_write (header_offset, sectp, sizeof (struct section)))
801 unexec_error ("cannot write section %s's header", sectp->sectname);
803 else if (strncmp (sectp->sectname, SECT_BSS, 16) == 0)
805 extern char *my_endbss_static;
806 unsigned long my_size;
808 sectp->flags = S_REGULAR;
810 /* Clear uninitialized local variables in statically linked
811 libraries. In particular, function pointers stored by
812 libSystemStub.a, which is introduced in Mac OS X 10.4 for
813 binary compatibility with respect to long double, are
814 cleared so that they will be reinitialized when the
815 dumped binary is executed on other versions of OS. */
816 my_size = (unsigned long)my_endbss_static - sectp->addr;
817 if (!(sectp->addr <= (unsigned long)my_endbss_static
818 && my_size <= sectp->size))
819 unexec_error ("my_endbss_static is not in section %s",
820 sectp->sectname);
821 if (!unexec_write (sectp->offset, (void *) sectp->addr, my_size))
822 unexec_error ("cannot write section %s", sectp->sectname);
823 if (!unexec_write_zero (sectp->offset + my_size,
824 sectp->size - my_size))
825 unexec_error ("cannot write section %s", sectp->sectname);
826 if (!unexec_write (header_offset, sectp, sizeof (struct section)))
827 unexec_error ("cannot write section %s's header", sectp->sectname);
829 else if (strncmp (sectp->sectname, "__la_symbol_ptr", 16) == 0
830 || strncmp (sectp->sectname, "__nl_symbol_ptr", 16) == 0
831 || strncmp (sectp->sectname, "__la_sym_ptr2", 16) == 0
832 || strncmp (sectp->sectname, "__dyld", 16) == 0
833 || strncmp (sectp->sectname, "__const", 16) == 0
834 || strncmp (sectp->sectname, "__cfstring", 16) == 0
835 || strncmp (sectp->sectname, "__gcc_except_tab", 16) == 0
836 || strncmp (sectp->sectname, "__program_vars", 16) == 0
837 || strncmp (sectp->sectname, "__objc_", 7) == 0)
839 if (!unexec_copy (sectp->offset, old_file_offset, sectp->size))
840 unexec_error ("cannot copy section %s", sectp->sectname);
841 if (!unexec_write (header_offset, sectp, sizeof (struct section)))
842 unexec_error ("cannot write section %s's header", sectp->sectname);
844 else
845 unexec_error ("unrecognized section name in __DATA segment");
847 printf (" section %-16.16s at %#8lx - %#8lx (sz: %#8lx)\n",
848 sectp->sectname, (long) (sectp->offset),
849 (long) (sectp->offset + sectp->size), (long) (sectp->size));
851 header_offset += sizeof (struct section);
852 sectp++;
855 curr_file_offset += ROUNDUP_TO_PAGE_BOUNDARY (scp->filesize);
857 if (!unexec_write (curr_header_offset, scp, sizeof (struct segment_command)))
858 unexec_error ("cannot write header of __DATA segment");
859 curr_header_offset += lc->cmdsize;
861 /* Create new __DATA segment load commands for regions on the region
862 list that do not corresponding to any segment load commands in
863 the input file.
865 for (j = 0; j < num_unexec_regions; j++)
867 struct segment_command sc;
869 sc.cmd = LC_SEGMENT;
870 sc.cmdsize = sizeof (struct segment_command);
871 strncpy (sc.segname, SEG_DATA, 16);
872 sc.vmaddr = unexec_regions[j].range.address;
873 sc.vmsize = unexec_regions[j].range.size;
874 sc.fileoff = curr_file_offset;
875 sc.filesize = unexec_regions[j].filesize;
876 sc.maxprot = VM_PROT_READ | VM_PROT_WRITE;
877 sc.initprot = VM_PROT_READ | VM_PROT_WRITE;
878 sc.nsects = 0;
879 sc.flags = 0;
881 printf ("Writing segment %-16.16s @ %#8lx (%#8lx/%#8lx @ %#10lx)\n",
882 sc.segname, (long) (sc.fileoff), (long) (sc.filesize),
883 (long) (sc.vmsize), (long) (sc.vmaddr));
885 if (!unexec_write (sc.fileoff, (void *) sc.vmaddr, sc.filesize))
886 unexec_error ("cannot write new __DATA segment");
887 curr_file_offset += ROUNDUP_TO_PAGE_BOUNDARY (sc.filesize);
889 if (!unexec_write (curr_header_offset, &sc, sc.cmdsize))
890 unexec_error ("cannot write new __DATA segment's header");
891 curr_header_offset += sc.cmdsize;
892 mh.ncmds++;
896 /* Copy a LC_SYMTAB load command from the input file to the output
897 file, adjusting the file offset fields. */
898 static void
899 copy_symtab (struct load_command *lc, long delta)
901 struct symtab_command *stp = (struct symtab_command *) lc;
903 stp->symoff += delta;
904 stp->stroff += delta;
906 printf ("Writing LC_SYMTAB command\n");
908 if (!unexec_write (curr_header_offset, lc, lc->cmdsize))
909 unexec_error ("cannot write symtab command to header");
911 curr_header_offset += lc->cmdsize;
914 /* Fix up relocation entries. */
915 static void
916 unrelocate (const char *name, off_t reloff, int nrel, vm_address_t base)
918 int i, unreloc_count;
919 struct relocation_info reloc_info;
920 struct scattered_relocation_info *sc_reloc_info
921 = (struct scattered_relocation_info *) &reloc_info;
922 vm_address_t location;
924 for (unreloc_count = 0, i = 0; i < nrel; i++)
926 if (lseek (infd, reloff, L_SET) != reloff)
927 unexec_error ("unrelocate: %s:%d cannot seek to reloc_info", name, i);
928 if (!unexec_read (&reloc_info, sizeof (reloc_info)))
929 unexec_error ("unrelocate: %s:%d cannot read reloc_info", name, i);
930 reloff += sizeof (reloc_info);
932 if (sc_reloc_info->r_scattered == 0)
933 switch (reloc_info.r_type)
935 case GENERIC_RELOC_VANILLA:
936 location = base + reloc_info.r_address;
937 if (location >= data_segment_scp->vmaddr
938 && location < (data_segment_scp->vmaddr
939 + data_segment_scp->vmsize))
941 off_t src_off = data_segment_old_fileoff
942 + (location - data_segment_scp->vmaddr);
943 off_t dst_off = data_segment_scp->fileoff
944 + (location - data_segment_scp->vmaddr);
946 if (!unexec_copy (dst_off, src_off, 1 << reloc_info.r_length))
947 unexec_error ("unrelocate: %s:%d cannot copy original value",
948 name, i);
949 unreloc_count++;
951 break;
952 default:
953 unexec_error ("unrelocate: %s:%d cannot handle type = %d",
954 name, i, reloc_info.r_type);
956 else
957 switch (sc_reloc_info->r_type)
959 #if defined (__ppc__)
960 case PPC_RELOC_PB_LA_PTR:
961 /* nothing to do for prebound lazy pointer */
962 break;
963 #endif
964 default:
965 unexec_error ("unrelocate: %s:%d cannot handle scattered type = %d",
966 name, i, sc_reloc_info->r_type);
970 if (nrel > 0)
971 printf ("Fixed up %d/%d %s relocation entries in data segment.\n",
972 unreloc_count, nrel, name);
975 #if __ppc64__
976 /* Rebase r_address in the relocation table. */
977 static void
978 rebase_reloc_address (off_t reloff, int nrel, long linkedit_delta, long diff)
980 int i;
981 struct relocation_info reloc_info;
982 struct scattered_relocation_info *sc_reloc_info
983 = (struct scattered_relocation_info *) &reloc_info;
985 for (i = 0; i < nrel; i++, reloff += sizeof (reloc_info))
987 if (lseek (infd, reloff - linkedit_delta, L_SET)
988 != reloff - linkedit_delta)
989 unexec_error ("rebase_reloc_table: cannot seek to reloc_info");
990 if (!unexec_read (&reloc_info, sizeof (reloc_info)))
991 unexec_error ("rebase_reloc_table: cannot read reloc_info");
993 if (sc_reloc_info->r_scattered == 0
994 && reloc_info.r_type == GENERIC_RELOC_VANILLA)
996 reloc_info.r_address -= diff;
997 if (!unexec_write (reloff, &reloc_info, sizeof (reloc_info)))
998 unexec_error ("rebase_reloc_table: cannot write reloc_info");
1002 #endif
1004 /* Copy a LC_DYSYMTAB load command from the input file to the output
1005 file, adjusting the file offset fields. */
1006 static void
1007 copy_dysymtab (struct load_command *lc, long delta)
1009 struct dysymtab_command *dstp = (struct dysymtab_command *) lc;
1010 vm_address_t base;
1012 #ifdef _LP64
1013 #if __ppc64__
1015 int i;
1017 base = 0;
1018 for (i = 0; i < nlc; i++)
1019 if (lca[i]->cmd == LC_SEGMENT)
1021 struct segment_command *scp = (struct segment_command *) lca[i];
1023 if (scp->vmaddr + scp->vmsize > 0x100000000
1024 && (scp->initprot & VM_PROT_WRITE) != 0)
1026 base = data_segment_scp->vmaddr;
1027 break;
1031 #else
1032 /* First writable segment address. */
1033 base = data_segment_scp->vmaddr;
1034 #endif
1035 #else
1036 /* First segment address in the file (unless MH_SPLIT_SEGS set). */
1037 base = 0;
1038 #endif
1040 unrelocate ("local", dstp->locreloff, dstp->nlocrel, base);
1041 unrelocate ("external", dstp->extreloff, dstp->nextrel, base);
1043 if (dstp->nextrel > 0) {
1044 dstp->extreloff += delta;
1047 if (dstp->nlocrel > 0) {
1048 dstp->locreloff += delta;
1051 if (dstp->nindirectsyms > 0)
1052 dstp->indirectsymoff += delta;
1054 printf ("Writing LC_DYSYMTAB command\n");
1056 if (!unexec_write (curr_header_offset, lc, lc->cmdsize))
1057 unexec_error ("cannot write symtab command to header");
1059 curr_header_offset += lc->cmdsize;
1061 #if __ppc64__
1062 /* Check if the relocation base needs to be changed. */
1063 if (base == 0)
1065 vm_address_t newbase = 0;
1066 int i;
1068 for (i = 0; i < num_unexec_regions; i++)
1069 if (unexec_regions[i].range.address + unexec_regions[i].range.size
1070 > 0x100000000)
1072 newbase = data_segment_scp->vmaddr;
1073 break;
1076 if (newbase)
1078 rebase_reloc_address (dstp->locreloff, dstp->nlocrel, delta, newbase);
1079 rebase_reloc_address (dstp->extreloff, dstp->nextrel, delta, newbase);
1082 #endif
1085 /* Copy a LC_TWOLEVEL_HINTS load command from the input file to the output
1086 file, adjusting the file offset fields. */
1087 static void
1088 copy_twolevelhints (struct load_command *lc, long delta)
1090 struct twolevel_hints_command *tlhp = (struct twolevel_hints_command *) lc;
1092 if (tlhp->nhints > 0) {
1093 tlhp->offset += delta;
1096 printf ("Writing LC_TWOLEVEL_HINTS command\n");
1098 if (!unexec_write (curr_header_offset, lc, lc->cmdsize))
1099 unexec_error ("cannot write two level hint command to header");
1101 curr_header_offset += lc->cmdsize;
1104 #ifdef LC_DYLD_INFO
1105 /* Copy a LC_DYLD_INFO(_ONLY) load command from the input file to the output
1106 file, adjusting the file offset fields. */
1107 static void
1108 copy_dyld_info (struct load_command *lc, long delta)
1110 struct dyld_info_command *dip = (struct dyld_info_command *) lc;
1112 if (dip->rebase_off > 0)
1113 dip->rebase_off += delta;
1114 if (dip->bind_off > 0)
1115 dip->bind_off += delta;
1116 if (dip->weak_bind_off > 0)
1117 dip->weak_bind_off += delta;
1118 if (dip->lazy_bind_off > 0)
1119 dip->lazy_bind_off += delta;
1120 if (dip->export_off > 0)
1121 dip->export_off += delta;
1123 printf ("Writing ");
1124 print_load_command_name (lc->cmd);
1125 printf (" command\n");
1127 if (!unexec_write (curr_header_offset, lc, lc->cmdsize))
1128 unexec_error ("cannot write dyld info command to header");
1130 curr_header_offset += lc->cmdsize;
1132 #endif
1134 /* Copy other kinds of load commands from the input file to the output
1135 file, ones that do not require adjustments of file offsets. */
1136 static void
1137 copy_other (struct load_command *lc)
1139 printf ("Writing ");
1140 print_load_command_name (lc->cmd);
1141 printf (" command\n");
1143 if (!unexec_write (curr_header_offset, lc, lc->cmdsize))
1144 unexec_error ("cannot write symtab command to header");
1146 curr_header_offset += lc->cmdsize;
1149 /* Loop through all load commands and dump them. Then write the Mach
1150 header. */
1151 static void
1152 dump_it (void)
1154 int i;
1155 long linkedit_delta = 0;
1157 printf ("--- Load Commands written to Output File ---\n");
1159 for (i = 0; i < nlc; i++)
1160 switch (lca[i]->cmd)
1162 case LC_SEGMENT:
1164 struct segment_command *scp = (struct segment_command *) lca[i];
1165 if (strncmp (scp->segname, SEG_DATA, 16) == 0)
1167 /* save data segment file offset and segment_command for
1168 unrelocate */
1169 if (data_segment_old_fileoff)
1170 unexec_error ("cannot handle multiple DATA segments"
1171 " in input file");
1172 data_segment_old_fileoff = scp->fileoff;
1173 data_segment_scp = scp;
1175 copy_data_segment (lca[i]);
1177 else
1179 if (strncmp (scp->segname, SEG_LINKEDIT, 16) == 0)
1181 if (linkedit_delta)
1182 unexec_error ("cannot handle multiple LINKEDIT segments"
1183 " in input file");
1184 linkedit_delta = curr_file_offset - scp->fileoff;
1187 copy_segment (lca[i]);
1190 break;
1191 case LC_SYMTAB:
1192 copy_symtab (lca[i], linkedit_delta);
1193 break;
1194 case LC_DYSYMTAB:
1195 copy_dysymtab (lca[i], linkedit_delta);
1196 break;
1197 case LC_TWOLEVEL_HINTS:
1198 copy_twolevelhints (lca[i], linkedit_delta);
1199 break;
1200 #ifdef LC_DYLD_INFO
1201 case LC_DYLD_INFO:
1202 case LC_DYLD_INFO_ONLY:
1203 copy_dyld_info (lca[i], linkedit_delta);
1204 break;
1205 #endif
1206 default:
1207 copy_other (lca[i]);
1208 break;
1211 if (curr_header_offset > text_seg_lowest_offset)
1212 unexec_error ("not enough room for load commands for new __DATA segments");
1214 printf ("%ld unused bytes follow Mach-O header\n",
1215 text_seg_lowest_offset - curr_header_offset);
1217 mh.sizeofcmds = curr_header_offset - sizeof (struct mach_header);
1218 if (!unexec_write (0, &mh, sizeof (struct mach_header)))
1219 unexec_error ("cannot write final header contents");
1222 /* Take a snapshot of Emacs and make a Mach-O format executable file
1223 from it. The file names of the output and input files are outfile
1224 and infile, respectively. The three other parameters are
1225 ignored. */
1227 unexec (const char *outfile, const char *infile)
1229 if (in_dumped_exec)
1230 unexec_error ("Unexec from a dumped executable is not supported.");
1232 pagesize = getpagesize ();
1233 infd = open (infile, O_RDONLY, 0);
1234 if (infd < 0)
1236 unexec_error ("cannot open input file `%s'", infile);
1239 outfd = open (outfile, O_WRONLY | O_TRUNC | O_CREAT, 0755);
1240 if (outfd < 0)
1242 close (infd);
1243 unexec_error ("cannot open output file `%s'", outfile);
1246 build_region_list ();
1247 read_load_commands ();
1249 find_emacs_zone_regions ();
1250 unexec_regions_merge ();
1252 in_dumped_exec = 1;
1254 dump_it ();
1256 close (outfd);
1257 return 0;
1261 void
1262 unexec_init_emacs_zone (void)
1264 emacs_zone = malloc_create_zone (0, 0);
1265 malloc_set_zone_name (emacs_zone, "EmacsZone");
1268 #ifndef MACOSX_MALLOC_MULT16
1269 #define MACOSX_MALLOC_MULT16 1
1270 #endif
1272 typedef struct unexec_malloc_header {
1273 union {
1274 char c[8];
1275 size_t size;
1276 } u;
1277 } unexec_malloc_header_t;
1279 #if MACOSX_MALLOC_MULT16
1281 #define ptr_in_unexec_regions(p) ((((vm_address_t) (p)) & 8) != 0)
1283 #else
1286 ptr_in_unexec_regions (void *ptr)
1288 int i;
1290 for (i = 0; i < num_unexec_regions; i++)
1291 if ((vm_address_t) ptr - unexec_regions[i].range.address
1292 < unexec_regions[i].range.size)
1293 return 1;
1295 return 0;
1298 #endif
1300 void *
1301 unexec_malloc (size_t size)
1303 if (in_dumped_exec)
1305 void *p;
1307 p = malloc (size);
1308 #if MACOSX_MALLOC_MULT16
1309 assert (((vm_address_t) p % 16) == 0);
1310 #endif
1311 return p;
1313 else
1315 unexec_malloc_header_t *ptr;
1317 ptr = (unexec_malloc_header_t *)
1318 malloc_zone_malloc (emacs_zone, size + sizeof (unexec_malloc_header_t));
1319 ptr->u.size = size;
1320 ptr++;
1321 #if MACOSX_MALLOC_MULT16
1322 assert (((vm_address_t) ptr % 16) == 8);
1323 #endif
1324 return (void *) ptr;
1328 void *
1329 unexec_realloc (void *old_ptr, size_t new_size)
1331 if (in_dumped_exec)
1333 void *p;
1335 if (ptr_in_unexec_regions (old_ptr))
1337 size_t old_size = ((unexec_malloc_header_t *) old_ptr)[-1].u.size;
1338 size_t size = new_size > old_size ? old_size : new_size;
1340 p = (size_t *) malloc (new_size);
1341 if (size)
1342 memcpy (p, old_ptr, size);
1344 else
1346 p = realloc (old_ptr, new_size);
1348 #if MACOSX_MALLOC_MULT16
1349 assert (((vm_address_t) p % 16) == 0);
1350 #endif
1351 return p;
1353 else
1355 unexec_malloc_header_t *ptr;
1357 ptr = (unexec_malloc_header_t *)
1358 malloc_zone_realloc (emacs_zone, (unexec_malloc_header_t *) old_ptr - 1,
1359 new_size + sizeof (unexec_malloc_header_t));
1360 ptr->u.size = new_size;
1361 ptr++;
1362 #if MACOSX_MALLOC_MULT16
1363 assert (((vm_address_t) ptr % 16) == 8);
1364 #endif
1365 return (void *) ptr;
1369 void
1370 unexec_free (void *ptr)
1372 if (ptr == NULL)
1373 return;
1374 if (in_dumped_exec)
1376 if (!ptr_in_unexec_regions (ptr))
1377 free (ptr);
1379 else
1380 malloc_zone_free (emacs_zone, (unexec_malloc_header_t *) ptr - 1);