src/file/file_macho.c

/*
 *  Copyright (C) 2005-2007  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: file_macho.c,v 1.3 2007/06/17 23:32:20 debug Exp $
 *
 *  COMMENT: Mach-O file support
 */

/*  Note: Included from file.c.  */


/*
 *  file_load_macho():
 *
 *  Loads a Mach-O binary image into the emulated memory. The entry point
 *  is stored in the specified CPU's registers.
 *
 *  TODO:
 *
 *      o)  Almost everything.
 *
 *      o)  I haven't had time to look into whether Apple's open source
 *          license is BSD-compatible or not. Perhaps it would be possible
 *          to use a header file containing symbolic names, and not use
 *          hardcoded values.
 */
static void file_load_macho(struct machine *m, struct memory *mem,
        char *filename, uint64_t *entrypointp, int arch, int *byte_orderp,
        int is_64bit, int is_reversed)
{
        FILE *f;
        uint64_t entry = 0;
        int entry_set = 0;
        int encoding = ELFDATA2MSB;
        unsigned char buf[65536];
        char *symbols, *strings;
        uint32_t cputype, cpusubtype, filetype, ncmds, sizeofcmds, flags;
        uint64_t vmaddr, vmsize, fileoff, filesize;
        int cmd_type, cmd_len, i, flavor;
        int32_t symoff, nsyms, stroff, strsize;
        size_t len, pos;

        if (m->cpus[0]->byte_order == EMUL_BIG_ENDIAN)
                encoding = ELFDATA2MSB;

        f = fopen(filename, "r");
        if (f == NULL) {
                perror(filename);
                exit(1);
        }

        if (is_64bit) {
                fatal("TODO: 64-bit Mach-O. Not supported yet.\n");
                exit(1);
        }
        if (is_reversed) {
                fatal("TODO: Reversed-endianness. Not supported yet.\n");
                exit(1);
        }

        len = fread(buf, 1, sizeof(buf), f);
        if (len < 100) {
                fatal("Bad Mach-O file?\n");
                exit(1);
        }

        unencode(cputype,    &buf[4], uint32_t);
        unencode(cpusubtype, &buf[8], uint32_t);
        unencode(filetype,   &buf[12], uint32_t);
        unencode(ncmds,      &buf[16], uint32_t);
        unencode(sizeofcmds, &buf[20], uint32_t);
        unencode(flags,      &buf[24], uint32_t);

        /*  debug("cputype=0x%x cpusubtype=0x%x filetype=0x%x\n",
            cputype, cpusubtype, filetype);
            debug("ncmds=%i sizeofcmds=0x%08x flags=0x%08x\n",
            ncmds, sizeofcmds, flags);  */

        /*
         *  Compare to "normal" values.
         *  NOTE/TODO: These were for a Darwin (Macintosh PPC) kernel.
         */
        if (cputype != 0x12) {
                fatal("Error: Unimplemented cputype 0x%x\n", cputype);
                exit(1);
        }
        if (cpusubtype != 0) {
                fatal("Error: Unimplemented cpusubtype 0x%x\n", cpusubtype);
                exit(1);
        }
        /*  Filetype 2 means an executable image.  */
        if (filetype != 2) {
                fatal("Error: Unimplemented filetype 0x%x\n", filetype);
                exit(1);
        }
        if (!(flags & 1)) {
                fatal("Error: File has 'undefined references'. Cannot"
                    " be executed.\n", flags);
                exit(1);
        }

        /*  I've only encountered flags == 1 so far.  */
        if (flags != 1) {
                fatal("Error: Unimplemented flags 0x%x\n", flags);
                exit(1);
        }

        /*
         *  Read all load commands:
         */
        pos = is_64bit? 32 : 28;
        cmd_type = 0;
        do {
                /*  Read command type and length:  */
                unencode(cmd_type, &buf[pos], uint32_t);
                unencode(cmd_len,  &buf[pos+4], uint32_t);

#if 0
                debug("cmd %i, len=%i\n", cmd_type, cmd_len);
                for (i=8; i<cmd_len; i++) {
                        unsigned char ch = buf[pos+i];
                        if (ch >= ' ' && ch < 127)
                                debug("%c", ch);
                        else
                                debug(".");
                }
#endif
                switch (cmd_type) {
                case 1: /*  LC_SEGMENT  */
                        debug("seg ");
                        for (i=0; i<16; i++) {
                                if (buf[pos + 8 + i] == 0)
                                        break;
                                debug("%c", buf[pos + 8 + i]);
                        }
                        unencode(vmaddr,   &buf[pos+8+16+0], uint32_t);
                        unencode(vmsize,   &buf[pos+8+16+4], uint32_t);
                        unencode(fileoff,  &buf[pos+8+16+8], uint32_t);
                        unencode(filesize, &buf[pos+8+16+12], uint32_t);
                        debug(": vmaddr=0x%x size=0x%x fileoff=0x%x",
                            (int)vmaddr, (int)vmsize, (int)fileoff);

                        if (filesize == 0) {
                                debug("\n");
                                break;
                        }

                        fseek(f, fileoff, SEEK_SET);

                        /*  Load data from the file:  */
                        while (filesize != 0) {
                                unsigned char buf[32768];
                                ssize_t len = filesize > sizeof(buf) ?
                                    sizeof(buf) : filesize;
                                len = fread(buf, 1, len, f);

                                /*  printf("fread len=%i vmaddr=%x buf[0..]="
                                    "%02x %02x %02x\n", (int)len, (int)vmaddr,
                                    buf[0], buf[1], buf[2]);  */

                                if (len > 0) {
                                        int len2 = 0;
                                        uint64_t vaddr1 = vmaddr &
                                            ((1 << BITS_PER_MEMBLOCK) - 1);
                                        uint64_t vaddr2 = (vmaddr +
                                            len) & ((1 << BITS_PER_MEMBLOCK)-1);
                                        if (vaddr2 < vaddr1) {
                                                len2 = len - vaddr2;
                                                m->cpus[0]->memory_rw(m->cpus[
                                                    0], mem, vmaddr, &buf[0],
                                                    len2, MEM_WRITE,
                                                    NO_EXCEPTIONS);
                                        }
                                        m->cpus[0]->memory_rw(m->cpus[0], mem,
                                            vmaddr + len2, &buf[len2], len-len2,
                                            MEM_WRITE, NO_EXCEPTIONS);
                                } else {
                                        fprintf(stderr, "error reading\n");
                                        exit(1);
                                }

                                vmaddr += len;
                                filesize -= len;
                        }

                        debug("\n");
                        break;

                case 2: /*  LC_SYMTAB  */
                        unencode(symoff,  &buf[pos+8], uint32_t);
                        unencode(nsyms,   &buf[pos+12], uint32_t);
                        unencode(stroff,  &buf[pos+16], uint32_t);
                        unencode(strsize, &buf[pos+20], uint32_t);
                        debug("symtable: %i symbols @ 0x%x (strings at "
                            "0x%x)\n", nsyms, symoff, stroff);

                        CHECK_ALLOCATION(symbols = malloc(12 * nsyms));
                        fseek(f, symoff, SEEK_SET);
                        fread(symbols, 1, 12 * nsyms, f);

                        CHECK_ALLOCATION(strings = malloc(strsize));
                        fseek(f, stroff, SEEK_SET);
                        fread(strings, 1, strsize, f);

                        for (i=0; i<nsyms; i++) {
                                int n_strx, n_type, n_sect, n_desc;
                                uint32_t n_value;
                                unencode(n_strx,  &symbols[i*12+0], int32_t);
                                unencode(n_type,  &symbols[i*12+4], uint8_t);
                                unencode(n_sect,  &symbols[i*12+5], uint8_t);
                                unencode(n_desc,  &symbols[i*12+6], int16_t);
                                unencode(n_value, &symbols[i*12+8], uint32_t);
                                /*  debug("%i: strx=%i type=%i sect=%i desc=%i"
                                    " value=0x%x\n", i, n_strx, n_type,
                                    n_sect, n_desc, n_value);  */
                                add_symbol_name(&m->symbol_context,
                                    n_value, 0, strings + n_strx, 0, -1);
                        }

                        free(symbols);
                        free(strings);
                        break;

                case 5: debug("unix thread context: ");
                        /*  See http://cvs.sf.net/viewcvs.py/hte/
                            HT%20Editor/machostruc.h or similar for details
                            on the thread struct.  */
                        unencode(flavor, &buf[pos+8], uint32_t);
                        if (flavor != 1) {
                                fatal("unimplemented flavor %i\n", flavor);
                                exit(1);
                        }

                        if (arch != ARCH_PPC) {
                                fatal("non-PPC arch? TODO\n");
                                exit(1);
                        }

                        unencode(entry, &buf[pos+16], uint32_t);
                        entry_set = 1;
                        debug("pc=0x%x\n", (int)entry);

                        for (i=1; i<40; i++) {
                                uint32_t x;
                                unencode(x, &buf[pos+16+i*4], uint32_t);
                                if (x != 0) {
                                        fatal("Entry nr %i in the Mach-O"
                                            " thread struct is non-zero"
                                            " (0x%x). This is not supported"
                                            " yet. TODO\n", i, x);
                                        exit(1);
                                }
                        }
                        break;

                default:fatal("WARNING! Unimplemented load command %i!\n",
                            cmd_type);
                }

                pos += cmd_len;
        } while (pos < sizeofcmds && cmd_type != 0);

        fclose(f);

        if (!entry_set) {
                fatal("No entry point? Aborting.\n");
                exit(1);
        }

        *entrypointp = entry;

        if (encoding == ELFDATA2LSB)
                *byte_orderp = EMUL_LITTLE_ENDIAN;
        else
                *byte_orderp = EMUL_BIG_ENDIAN;

        n_executables_loaded ++;
}

1	dpavlin	38	/*
2			* Copyright (C) 2005-2007 Anders Gavare. All rights reserved.
3			*
4			* Redistribution and use in source and binary forms, with or without
5			* modification, are permitted provided that the following conditions are met:
6			*
7			* 1. Redistributions of source code must retain the above copyright
8			* notice, this list of conditions and the following disclaimer.
9			* 2. Redistributions in binary form must reproduce the above copyright
10			* notice, this list of conditions and the following disclaimer in the
11			* documentation and/or other materials provided with the distribution.
12			* 3. The name of the author may not be used to endorse or promote products
13			* derived from this software without specific prior written permission.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*
27			*
28	dpavlin	44	* $Id: file_macho.c,v 1.3 2007/06/17 23:32:20 debug Exp $
29	dpavlin	38	*
30	dpavlin	44	* COMMENT: Mach-O file support
31	dpavlin	38	*/
32
33			/* Note: Included from file.c. */
34
35
36			/*
37			* file_load_macho():
38			*
39			* Loads a Mach-O binary image into the emulated memory. The entry point
40			* is stored in the specified CPU's registers.
41			*
42			* TODO:
43			*
44			* o) Almost everything.
45			*
46			* o) I haven't had time to look into whether Apple's open source
47			* license is BSD-compatible or not. Perhaps it would be possible
48			* to use a header file containing symbolic names, and not use
49			* hardcoded values.
50			*/
51			static void file_load_macho(struct machine m, struct memory mem,
52			char filename, uint64_t entrypointp, int arch, int *byte_orderp,
53			int is_64bit, int is_reversed)
54			{
55			FILE *f;
56			uint64_t entry = 0;
57			int entry_set = 0;
58			int encoding = ELFDATA2MSB;
59			unsigned char buf[65536];
60			char symbols, strings;
61			uint32_t cputype, cpusubtype, filetype, ncmds, sizeofcmds, flags;
62			uint64_t vmaddr, vmsize, fileoff, filesize;
63			int cmd_type, cmd_len, i, flavor;
64			int32_t symoff, nsyms, stroff, strsize;
65			size_t len, pos;
66
67			if (m->cpus[0]->byte_order == EMUL_BIG_ENDIAN)
68			encoding = ELFDATA2MSB;
69
70			f = fopen(filename, "r");
71			if (f == NULL) {
72			perror(filename);
73			exit(1);
74			}
75
76			if (is_64bit) {
77			fatal("TODO: 64-bit Mach-O. Not supported yet.\n");
78			exit(1);
79			}
80			if (is_reversed) {
81			fatal("TODO: Reversed-endianness. Not supported yet.\n");
82			exit(1);
83			}
84
85			len = fread(buf, 1, sizeof(buf), f);
86			if (len < 100) {
87			fatal("Bad Mach-O file?\n");
88			exit(1);
89			}
90
91			unencode(cputype, &buf[4], uint32_t);
92			unencode(cpusubtype, &buf[8], uint32_t);
93			unencode(filetype, &buf[12], uint32_t);
94			unencode(ncmds, &buf[16], uint32_t);
95			unencode(sizeofcmds, &buf[20], uint32_t);
96			unencode(flags, &buf[24], uint32_t);
97
98			/* debug("cputype=0x%x cpusubtype=0x%x filetype=0x%x\n",
99			cputype, cpusubtype, filetype);
100			debug("ncmds=%i sizeofcmds=0x%08x flags=0x%08x\n",
101			ncmds, sizeofcmds, flags); */
102
103			/*
104			* Compare to "normal" values.
105			* NOTE/TODO: These were for a Darwin (Macintosh PPC) kernel.
106			*/
107			if (cputype != 0x12) {
108			fatal("Error: Unimplemented cputype 0x%x\n", cputype);
109			exit(1);
110			}
111			if (cpusubtype != 0) {
112			fatal("Error: Unimplemented cpusubtype 0x%x\n", cpusubtype);
113			exit(1);
114			}
115			/* Filetype 2 means an executable image. */
116			if (filetype != 2) {
117			fatal("Error: Unimplemented filetype 0x%x\n", filetype);
118			exit(1);
119			}
120			if (!(flags & 1)) {
121			fatal("Error: File has 'undefined references'. Cannot"
122			" be executed.\n", flags);
123			exit(1);
124			}
125
126			/* I've only encountered flags == 1 so far. */
127			if (flags != 1) {
128			fatal("Error: Unimplemented flags 0x%x\n", flags);
129			exit(1);
130			}
131
132			/*
133			* Read all load commands:
134			*/
135			pos = is_64bit? 32 : 28;
136			cmd_type = 0;
137			do {
138			/* Read command type and length: */
139			unencode(cmd_type, &buf[pos], uint32_t);
140			unencode(cmd_len, &buf[pos+4], uint32_t);
141
142			#if 0
143			debug("cmd %i, len=%i\n", cmd_type, cmd_len);
144			for (i=8; i<cmd_len; i++) {
145			unsigned char ch = buf[pos+i];
146			if (ch >= ' ' && ch < 127)
147			debug("%c", ch);
148			else
149			debug(".");
150			}
151			#endif
152			switch (cmd_type) {
153			case 1: /* LC_SEGMENT */
154			debug("seg ");
155			for (i=0; i<16; i++) {
156			if (buf[pos + 8 + i] == 0)
157			break;
158			debug("%c", buf[pos + 8 + i]);
159			}
160			unencode(vmaddr, &buf[pos+8+16+0], uint32_t);
161			unencode(vmsize, &buf[pos+8+16+4], uint32_t);
162			unencode(fileoff, &buf[pos+8+16+8], uint32_t);
163			unencode(filesize, &buf[pos+8+16+12], uint32_t);
164			debug(": vmaddr=0x%x size=0x%x fileoff=0x%x",
165			(int)vmaddr, (int)vmsize, (int)fileoff);
166
167			if (filesize == 0) {
168			debug("\n");
169			break;
170			}
171
172			fseek(f, fileoff, SEEK_SET);
173
174			/* Load data from the file: */
175			while (filesize != 0) {
176			unsigned char buf[32768];
177			ssize_t len = filesize > sizeof(buf) ?
178			sizeof(buf) : filesize;
179			len = fread(buf, 1, len, f);
180
181			/* printf("fread len=%i vmaddr=%x buf[0..]="
182			"%02x %02x %02x\n", (int)len, (int)vmaddr,
183			buf[0], buf[1], buf[2]); */
184
185			if (len > 0) {
186			int len2 = 0;
187			uint64_t vaddr1 = vmaddr &
188			((1 << BITS_PER_MEMBLOCK) - 1);
189			uint64_t vaddr2 = (vmaddr +
190			len) & ((1 << BITS_PER_MEMBLOCK)-1);
191			if (vaddr2 < vaddr1) {
192			len2 = len - vaddr2;
193			m->cpus[0]->memory_rw(m->cpus[
194			0], mem, vmaddr, &buf[0],
195			len2, MEM_WRITE,
196			NO_EXCEPTIONS);
197			}
198			m->cpus[0]->memory_rw(m->cpus[0], mem,
199			vmaddr + len2, &buf[len2], len-len2,
200			MEM_WRITE, NO_EXCEPTIONS);
201			} else {
202			fprintf(stderr, "error reading\n");
203			exit(1);
204			}
205
206			vmaddr += len;
207			filesize -= len;
208			}
209
210			debug("\n");
211			break;
212
213			case 2: /* LC_SYMTAB */
214			unencode(symoff, &buf[pos+8], uint32_t);
215			unencode(nsyms, &buf[pos+12], uint32_t);
216			unencode(stroff, &buf[pos+16], uint32_t);
217			unencode(strsize, &buf[pos+20], uint32_t);
218			debug("symtable: %i symbols @ 0x%x (strings at "
219			"0x%x)\n", nsyms, symoff, stroff);
220
221	dpavlin	42	CHECK_ALLOCATION(symbols = malloc(12 * nsyms));
222	dpavlin	38	fseek(f, symoff, SEEK_SET);
223			fread(symbols, 1, 12 * nsyms, f);
224
225	dpavlin	42	CHECK_ALLOCATION(strings = malloc(strsize));
226	dpavlin	38	fseek(f, stroff, SEEK_SET);
227			fread(strings, 1, strsize, f);
228
229			for (i=0; i<nsyms; i++) {
230			int n_strx, n_type, n_sect, n_desc;
231			uint32_t n_value;
232			unencode(n_strx, &symbols[i*12+0], int32_t);
233			unencode(n_type, &symbols[i*12+4], uint8_t);
234			unencode(n_sect, &symbols[i*12+5], uint8_t);
235			unencode(n_desc, &symbols[i*12+6], int16_t);
236			unencode(n_value, &symbols[i*12+8], uint32_t);
237			/* debug("%i: strx=%i type=%i sect=%i desc=%i"
238			" value=0x%x\n", i, n_strx, n_type,
239			n_sect, n_desc, n_value); */
240			add_symbol_name(&m->symbol_context,
241			n_value, 0, strings + n_strx, 0, -1);
242			}
243
244			free(symbols);
245			free(strings);
246			break;
247
248			case 5: debug("unix thread context: ");
249			/* See http://cvs.sf.net/viewcvs.py/hte/
250			HT%20Editor/machostruc.h or similar for details
251			on the thread struct. */
252			unencode(flavor, &buf[pos+8], uint32_t);
253			if (flavor != 1) {
254			fatal("unimplemented flavor %i\n", flavor);
255			exit(1);
256			}
257
258			if (arch != ARCH_PPC) {
259			fatal("non-PPC arch? TODO\n");
260			exit(1);
261			}
262
263			unencode(entry, &buf[pos+16], uint32_t);
264			entry_set = 1;
265			debug("pc=0x%x\n", (int)entry);
266
267			for (i=1; i<40; i++) {
268			uint32_t x;
269			unencode(x, &buf[pos+16+i*4], uint32_t);
270			if (x != 0) {
271			fatal("Entry nr %i in the Mach-O"
272			" thread struct is non-zero"
273			" (0x%x). This is not supported"
274			" yet. TODO\n", i, x);
275			exit(1);
276			}
277			}
278			break;
279
280			default:fatal("WARNING! Unimplemented load command %i!\n",
281			cmd_type);
282			}
283
284			pos += cmd_len;
285			} while (pos < sizeofcmds && cmd_type != 0);
286
287			fclose(f);
288
289			if (!entry_set) {
290			fatal("No entry point? Aborting.\n");
291			exit(1);
292			}
293
294			*entrypointp = entry;
295
296			if (encoding == ELFDATA2LSB)
297			*byte_orderp = EMUL_LITTLE_ENDIAN;
298			else
299			*byte_orderp = EMUL_BIG_ENDIAN;
300
301			n_executables_loaded ++;
302			}
303