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
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
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
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. */
101 #include <sys/types.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>
109 #ifdef HAVE_MALLOC_MALLOC_H
110 #include <malloc/malloc.h>
112 #include <objc/malloc.h>
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
125 #define LC_SEGMENT LC_SEGMENT_64
126 #define vm_region vm_region_64
127 #define section section_64
129 #define MH_MAGIC MH_MAGIC_64
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. */
144 vm_address_t address
;
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. */
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;
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. */
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
211 unexec_write (off_t dest
, const void *src
, size_t count
)
213 if (lseek (outfd
, dest
, SEEK_SET
) != dest
)
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. */
222 unexec_write_zero (off_t dest
, size_t count
)
224 char buf
[UNEXEC_COPY_BUFSZ
];
227 memset (buf
, 0, UNEXEC_COPY_BUFSZ
);
228 if (lseek (outfd
, dest
, SEEK_SET
) != dest
)
233 bytes
= count
> UNEXEC_COPY_BUFSZ
? UNEXEC_COPY_BUFSZ
: count
;
234 if (write (outfd
, buf
, bytes
) != bytes
)
242 /* Copy COUNT bytes from starting offset SRC in infd to starting
243 offset DEST in outfd. Return true if successful, false
246 unexec_copy (off_t dest
, off_t src
, ssize_t count
)
249 ssize_t bytes_to_read
;
251 char buf
[UNEXEC_COPY_BUFSZ
];
253 if (lseek (infd
, src
, SEEK_SET
) != src
)
256 if (lseek (outfd
, dest
, SEEK_SET
) != dest
)
261 bytes_to_read
= count
> UNEXEC_COPY_BUFSZ
? UNEXEC_COPY_BUFSZ
: count
;
262 bytes_read
= read (infd
, buf
, bytes_to_read
);
265 if (write (outfd
, buf
, bytes_read
) != bytes_read
)
273 /* Debugging and informational messages routines. */
276 unexec_error (const char *format
, ...)
280 va_start (ap
, format
);
281 fprintf (stderr
, "unexec: ");
282 vfprintf (stderr
, format
, ap
);
283 fprintf (stderr
, "\n");
289 print_prot (vm_prot_t prot
)
291 if (prot
== VM_PROT_NONE
)
295 putchar (prot
& VM_PROT_READ
? 'r' : ' ');
296 putchar (prot
& VM_PROT_WRITE
? 'w' : ' ');
297 putchar (prot
& VM_PROT_EXECUTE
? 'x' : ' ');
303 print_region (vm_address_t address
, vm_size_t size
, vm_prot_t prot
,
306 printf ("%#10lx %#8lx ", (long) address
, (long) size
);
309 print_prot (max_prot
);
314 print_region_list (void)
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
);
327 task_t target_task
= mach_task_self ();
328 vm_address_t address
= (vm_address_t
) 0;
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
);
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
355 build_region_list (void)
357 task_t target_task
= mach_task_self ();
358 vm_address_t address
= (vm_address_t
) 0;
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
;
366 printf ("--- List of All Regions ---\n");
367 printf (" address size prot maxp\n");
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
)
380 print_region (address
, size
, info
.protection
, info
.max_protection
);
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. */
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
;
396 r
= (struct region_t
*) malloc (sizeof (struct region_t
));
399 unexec_error ("cannot allocate region structure");
401 r
->address
= address
;
403 r
->protection
= info
.protection
;
404 r
->max_protection
= info
.max_protection
;
407 if (region_list_head
== 0)
409 region_list_head
= r
;
410 region_list_tail
= r
;
414 region_list_tail
->next
= r
;
415 region_list_tail
= r
;
418 /* Deallocate (unused) object name returned by
420 if (object_name
!= MACH_PORT_NULL
)
421 mach_port_deallocate (target_task
, object_name
);
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
;
438 } unexec_region_info
;
439 static unexec_region_info unexec_regions
[MAX_UNEXEC_REGIONS
];
442 unexec_regions_recorder (task_t task
, void *rr
, unsigned type
,
443 vm_range_t
*ranges
, unsigned num
)
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))
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
));
467 unexec_reader (task_t task
, vm_address_t address
, vm_size_t size
, void **ptr
)
469 *ptr
= (void *) address
;
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
,
483 unexec_regions_recorder
);
485 if (num_unexec_regions
== MAX_UNEXEC_REGIONS
)
486 unexec_error ("find_emacs_zone_regions: too many regions");
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
;
504 unexec_regions_merge (void)
507 unexec_region_info r
;
510 qsort (unexec_regions
, num_unexec_regions
, sizeof (unexec_regions
[0]),
511 &unexec_regions_sort_compare
);
513 r
= unexec_regions
[0];
514 padsize
= r
.range
.address
& (pagesize
- 1);
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
;
531 unexec_regions
[n
++] = r
;
532 r
= unexec_regions
[i
];
533 padsize
= r
.range
.address
& (pagesize
- 1);
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. */
554 print_load_command_name (int lc
)
560 printf ("LC_SEGMENT ");
562 printf ("LC_SEGMENT_64 ");
565 case LC_LOAD_DYLINKER
:
566 printf ("LC_LOAD_DYLINKER ");
569 printf ("LC_LOAD_DYLIB ");
572 printf ("LC_SYMTAB ");
575 printf ("LC_DYSYMTAB ");
578 printf ("LC_UNIXTHREAD ");
580 case LC_PREBOUND_DYLIB
:
581 printf ("LC_PREBOUND_DYLIB");
583 case LC_TWOLEVEL_HINTS
:
584 printf ("LC_TWOLEVEL_HINTS");
593 printf ("LC_DYLD_INFO ");
595 case LC_DYLD_INFO_ONLY
:
596 printf ("LC_DYLD_INFO_ONLY");
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
;
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
));
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. */
636 read_load_commands (void)
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");
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
);
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);
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
++)
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. */
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
;
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
;
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. */
756 copy_data_segment (struct load_command
*lc
)
758 struct segment_command
*scp
= (struct segment_command
*) lc
;
759 struct section
*sectp
;
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
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",
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
);
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
);
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
865 for (j
= 0; j
< num_unexec_regions
; j
++)
867 struct segment_command sc
;
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
;
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
;
896 /* Copy a LC_SYMTAB load command from the input file to the output
897 file, adjusting the file offset fields. */
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. */
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",
953 unexec_error ("unrelocate: %s:%d cannot handle type = %d",
954 name
, i
, reloc_info
.r_type
);
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 */
965 unexec_error ("unrelocate: %s:%d cannot handle scattered type = %d",
966 name
, i
, sc_reloc_info
->r_type
);
971 printf ("Fixed up %d/%d %s relocation entries in data segment.\n",
972 unreloc_count
, nrel
, name
);
976 /* Rebase r_address in the relocation table. */
978 rebase_reloc_address (off_t reloff
, int nrel
, long linkedit_delta
, long diff
)
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");
1004 /* Copy a LC_DYSYMTAB load command from the input file to the output
1005 file, adjusting the file offset fields. */
1007 copy_dysymtab (struct load_command
*lc
, long delta
)
1009 struct dysymtab_command
*dstp
= (struct dysymtab_command
*) lc
;
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
;
1032 /* First writable segment address. */
1033 base
= data_segment_scp
->vmaddr
;
1036 /* First segment address in the file (unless MH_SPLIT_SEGS set). */
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
;
1062 /* Check if the relocation base needs to be changed. */
1065 vm_address_t newbase
= 0;
1068 for (i
= 0; i
< num_unexec_regions
; i
++)
1069 if (unexec_regions
[i
].range
.address
+ unexec_regions
[i
].range
.size
1072 newbase
= data_segment_scp
->vmaddr
;
1078 rebase_reloc_address (dstp
->locreloff
, dstp
->nlocrel
, delta
, newbase
);
1079 rebase_reloc_address (dstp
->extreloff
, dstp
->nextrel
, delta
, newbase
);
1085 /* Copy a LC_TWOLEVEL_HINTS load command from the input file to the output
1086 file, adjusting the file offset fields. */
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
;
1105 /* Copy a LC_DYLD_INFO(_ONLY) load command from the input file to the output
1106 file, adjusting the file offset fields. */
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
;
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. */
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
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
)
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
1169 if (data_segment_old_fileoff
)
1170 unexec_error ("cannot handle multiple DATA segments"
1172 data_segment_old_fileoff
= scp
->fileoff
;
1173 data_segment_scp
= scp
;
1175 copy_data_segment (lca
[i
]);
1179 if (strncmp (scp
->segname
, SEG_LINKEDIT
, 16) == 0)
1182 unexec_error ("cannot handle multiple LINKEDIT segments"
1184 linkedit_delta
= curr_file_offset
- scp
->fileoff
;
1187 copy_segment (lca
[i
]);
1192 copy_symtab (lca
[i
], linkedit_delta
);
1195 copy_dysymtab (lca
[i
], linkedit_delta
);
1197 case LC_TWOLEVEL_HINTS
:
1198 copy_twolevelhints (lca
[i
], linkedit_delta
);
1202 case LC_DYLD_INFO_ONLY
:
1203 copy_dyld_info (lca
[i
], linkedit_delta
);
1207 copy_other (lca
[i
]);
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
1227 unexec (const char *outfile
, const char *infile
)
1230 unexec_error ("Unexec from a dumped executable is not supported.");
1232 pagesize
= getpagesize ();
1233 infd
= open (infile
, O_RDONLY
, 0);
1236 unexec_error ("cannot open input file `%s'", infile
);
1239 outfd
= open (outfile
, O_WRONLY
| O_TRUNC
| O_CREAT
, 0755);
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 ();
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
1272 typedef struct unexec_malloc_header
{
1277 } unexec_malloc_header_t
;
1279 #if MACOSX_MALLOC_MULT16
1281 #define ptr_in_unexec_regions(p) ((((vm_address_t) (p)) & 8) != 0)
1286 ptr_in_unexec_regions (void *ptr
)
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
)
1301 unexec_malloc (size_t size
)
1308 #if MACOSX_MALLOC_MULT16
1309 assert (((vm_address_t
) p
% 16) == 0);
1315 unexec_malloc_header_t
*ptr
;
1317 ptr
= (unexec_malloc_header_t
*)
1318 malloc_zone_malloc (emacs_zone
, size
+ sizeof (unexec_malloc_header_t
));
1321 #if MACOSX_MALLOC_MULT16
1322 assert (((vm_address_t
) ptr
% 16) == 8);
1324 return (void *) ptr
;
1329 unexec_realloc (void *old_ptr
, size_t new_size
)
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
);
1342 memcpy (p
, old_ptr
, size
);
1346 p
= realloc (old_ptr
, new_size
);
1348 #if MACOSX_MALLOC_MULT16
1349 assert (((vm_address_t
) p
% 16) == 0);
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
;
1362 #if MACOSX_MALLOC_MULT16
1363 assert (((vm_address_t
) ptr
% 16) == 8);
1365 return (void *) ptr
;
1370 unexec_free (void *ptr
)
1376 if (!ptr_in_unexec_regions (ptr
))
1380 malloc_zone_free (emacs_zone
, (unexec_malloc_header_t
*) ptr
- 1);