src/file/file_aout.c

/*
 *  Copyright (C) 2003-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_aout.c,v 1.2 2007/04/19 15:18:16 debug Exp $
 *
 *  a.out file support.
 */

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


#include "exec_aout.h"


#define AOUT_FLAG_DECOSF1               1
#define AOUT_FLAG_FROM_BEGINNING        2
#define AOUT_FLAG_VADDR_ZERO_HACK       4
#define AOUT_FLAG_NO_SIZES              8

struct aout_symbol {
        uint32_t        strindex;
        uint32_t        type;
        uint32_t        addr;
};


/*
 *  file_load_aout():
 *
 *  Loads an a.out binary image into the emulated memory.  The entry point
 *  (read from the a.out header) is stored in the specified CPU's registers.
 *
 *  TODO:  This has to be rewritten / corrected to support multiple a.out
 *         formats, where text/data are aligned differently.
 */
static void file_load_aout(struct machine *m, struct memory *mem,
        char *filename, int flags,
        uint64_t *entrypointp, int arch, int *byte_orderp)
{
        struct exec aout_header;
        FILE *f;
        int len;
        int encoding = ELFDATA2LSB;
        uint32_t entry, datasize, textsize;
        int32_t symbsize = 0;
        uint32_t vaddr, total_len;
        unsigned char buf[65536];
        unsigned char *syms;

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

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

        if (flags & AOUT_FLAG_DECOSF1) {
                fread(&buf, 1, 32, f);
                vaddr = buf[16] + (buf[17] << 8) +
                    (buf[18] << 16) + ((uint64_t)buf[19] << 24);
                entry = buf[20] + (buf[21] << 8) +
                    (buf[22] << 16) + ((uint64_t)buf[23] << 24);
                debug("OSF1 a.out, load address 0x%08lx, "
                    "entry point 0x%08x\n", (long)vaddr, (long)entry);
                symbsize = 0;
                fseek(f, 0, SEEK_END);
                /*  This is of course wrong, but should work anyway:  */
                textsize = ftello(f) - 512;
                datasize = 0;
                fseek(f, 512, SEEK_SET);
        } else if (flags & AOUT_FLAG_NO_SIZES) {
                fseek(f, 0, SEEK_END);
                textsize = ftello(f) - 32;
                datasize = 0;
                vaddr = entry = 0;
                fseek(f, 32, SEEK_SET);
        } else {
                len = fread(&aout_header, 1, sizeof(aout_header), f);
                if (len != sizeof(aout_header)) {
                        fprintf(stderr, "%s: not a complete a.out image\n",
                            filename);
                        exit(1);
                }

                unencode(entry, &aout_header.a_entry, uint32_t);
                debug("a.out, entry point 0x%08lx\n", (long)entry);
                vaddr = entry;

                if (flags & AOUT_FLAG_VADDR_ZERO_HACK)
                        vaddr = 0;

                unencode(textsize, &aout_header.a_text, uint32_t);
                unencode(datasize, &aout_header.a_data, uint32_t);
                debug("text + data = %i + %i bytes\n", textsize, datasize);

                unencode(symbsize, &aout_header.a_syms, uint32_t);
        }

        if (flags & AOUT_FLAG_FROM_BEGINNING) {
                fseek(f, 0, SEEK_SET);
                vaddr &= ~0xfff;
        }

        /*  Load text and data:  */
        total_len = textsize + datasize;
        while (total_len != 0) {
                len = total_len > sizeof(buf) ? sizeof(buf) : total_len;
                len = fread(buf, 1, len, f);

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

                if (len > 0) {
                        int len2 = 0;
                        uint64_t vaddr1 = vaddr &
                            ((1 << BITS_PER_MEMBLOCK) - 1);
                        uint64_t vaddr2 = (vaddr +
                            len) & ((1 << BITS_PER_MEMBLOCK) - 1);
                        if (vaddr2 < vaddr1) {
                                len2 = len - vaddr2;
                                m->cpus[0]->memory_rw(m->cpus[0], mem, vaddr,
                                    &buf[0], len2, MEM_WRITE, NO_EXCEPTIONS);
                        }
                        m->cpus[0]->memory_rw(m->cpus[0], mem, vaddr + len2,
                            &buf[len2], len-len2, MEM_WRITE, NO_EXCEPTIONS);
                } else {
                        if (flags & AOUT_FLAG_DECOSF1)
                                break;
                        else {
                                fprintf(stderr, "could not read from %s,"
                                    " wanted to read %i bytes\n", filename,
                                    (int) total_len);
                                exit(1);
                        }
                }

                vaddr += len;
                total_len -= len;
        }

        if (symbsize != 0) {
                struct aout_symbol *aout_symbol_ptr;
                int i, n_symbols;
                uint32_t type, addr, str_index;
                uint32_t strings_len;
                char *string_symbols;
                off_t oldpos;

                debug("symbols: %i bytes @ 0x%x\n", symbsize, (int)ftello(f));
                syms = malloc(symbsize);
                if (syms == NULL) {
                        fprintf(stderr, "out of memory\n");
                        exit(1);
                }
                len = fread(syms, 1, symbsize, f);
                if (len != symbsize) {
                        fprintf(stderr, "error reading symbols from %s\n",
                            filename);
                        exit(1);
                }

                oldpos = ftello(f);
                fseek(f, 0, SEEK_END);
                strings_len = ftello(f) - oldpos;
                fseek(f, oldpos, SEEK_SET);
                debug("strings: %i bytes @ 0x%x\n", strings_len,(int)ftello(f));
                string_symbols = malloc(strings_len);
                if (string_symbols == NULL) {
                        fprintf(stderr, "out of memory\n");
                        exit(1);
                }
                fread(string_symbols, 1, strings_len, f);

                aout_symbol_ptr = (struct aout_symbol *) syms;
                n_symbols = symbsize / sizeof(struct aout_symbol);
                i = 0;
                while (i < n_symbols) {
                        unencode(str_index, &aout_symbol_ptr[i].strindex,
                            uint32_t);
                        unencode(type, &aout_symbol_ptr[i].type, uint32_t);
                        unencode(addr, &aout_symbol_ptr[i].addr, uint32_t);

                        /*  debug("symbol type 0x%04x @ 0x%08x: %s\n",
                            type, addr, string_symbols + str_index);  */

                        if (type != 0 && addr != 0)
                                add_symbol_name(&m->symbol_context,
                                    addr, 0, string_symbols + str_index, 0, -1);
                        i++;
                }

                free(string_symbols);
                free(syms);
        }

        fclose(f);

        *entrypointp = (int32_t)entry;

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

        n_executables_loaded ++;
}

1	dpavlin	38	/*
2			* Copyright (C) 2003-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	40	* $Id: file_aout.c,v 1.2 2007/04/19 15:18:16 debug Exp $
29	dpavlin	38	*
30			* a.out file support.
31			*/
32
33			/* Note: Included from file.c. */
34
35
36			#include "exec_aout.h"
37
38
39			#define AOUT_FLAG_DECOSF1 1
40			#define AOUT_FLAG_FROM_BEGINNING 2
41			#define AOUT_FLAG_VADDR_ZERO_HACK 4
42			#define AOUT_FLAG_NO_SIZES 8
43
44			struct aout_symbol {
45			uint32_t strindex;
46			uint32_t type;
47			uint32_t addr;
48			};
49
50
51			/*
52			* file_load_aout():
53			*
54			* Loads an a.out binary image into the emulated memory. The entry point
55			* (read from the a.out header) is stored in the specified CPU's registers.
56			*
57			* TODO: This has to be rewritten / corrected to support multiple a.out
58			* formats, where text/data are aligned differently.
59			*/
60			static void file_load_aout(struct machine m, struct memory mem,
61			char *filename, int flags,
62			uint64_t entrypointp, int arch, int byte_orderp)
63			{
64			struct exec aout_header;
65			FILE *f;
66			int len;
67			int encoding = ELFDATA2LSB;
68			uint32_t entry, datasize, textsize;
69			int32_t symbsize = 0;
70			uint32_t vaddr, total_len;
71			unsigned char buf[65536];
72			unsigned char *syms;
73
74			if (m->cpus[0]->byte_order == EMUL_BIG_ENDIAN)
75			encoding = ELFDATA2MSB;
76
77			f = fopen(filename, "r");
78			if (f == NULL) {
79			perror(filename);
80			exit(1);
81			}
82
83			if (flags & AOUT_FLAG_DECOSF1) {
84			fread(&buf, 1, 32, f);
85			vaddr = buf[16] + (buf[17] << 8) +
86			(buf[18] << 16) + ((uint64_t)buf[19] << 24);
87			entry = buf[20] + (buf[21] << 8) +
88			(buf[22] << 16) + ((uint64_t)buf[23] << 24);
89			debug("OSF1 a.out, load address 0x%08lx, "
90			"entry point 0x%08x\n", (long)vaddr, (long)entry);
91			symbsize = 0;
92			fseek(f, 0, SEEK_END);
93			/* This is of course wrong, but should work anyway: */
94			textsize = ftello(f) - 512;
95			datasize = 0;
96			fseek(f, 512, SEEK_SET);
97			} else if (flags & AOUT_FLAG_NO_SIZES) {
98			fseek(f, 0, SEEK_END);
99			textsize = ftello(f) - 32;
100			datasize = 0;
101			vaddr = entry = 0;
102			fseek(f, 32, SEEK_SET);
103			} else {
104			len = fread(&aout_header, 1, sizeof(aout_header), f);
105			if (len != sizeof(aout_header)) {
106			fprintf(stderr, "%s: not a complete a.out image\n",
107			filename);
108			exit(1);
109			}
110
111			unencode(entry, &aout_header.a_entry, uint32_t);
112			debug("a.out, entry point 0x%08lx\n", (long)entry);
113			vaddr = entry;
114
115			if (flags & AOUT_FLAG_VADDR_ZERO_HACK)
116			vaddr = 0;
117
118			unencode(textsize, &aout_header.a_text, uint32_t);
119			unencode(datasize, &aout_header.a_data, uint32_t);
120			debug("text + data = %i + %i bytes\n", textsize, datasize);
121
122			unencode(symbsize, &aout_header.a_syms, uint32_t);
123			}
124
125			if (flags & AOUT_FLAG_FROM_BEGINNING) {
126			fseek(f, 0, SEEK_SET);
127			vaddr &= ~0xfff;
128			}
129
130			/* Load text and data: */
131			total_len = textsize + datasize;
132			while (total_len != 0) {
133			len = total_len > sizeof(buf) ? sizeof(buf) : total_len;
134			len = fread(buf, 1, len, f);
135
136			/* printf("fread len=%i vaddr=%x buf[0..]=%02x %02x %02x\n",
137			(int)len, (int)vaddr, buf[0], buf[1], buf[2]); */
138
139			if (len > 0) {
140			int len2 = 0;
141			uint64_t vaddr1 = vaddr &
142			((1 << BITS_PER_MEMBLOCK) - 1);
143			uint64_t vaddr2 = (vaddr +
144			len) & ((1 << BITS_PER_MEMBLOCK) - 1);
145			if (vaddr2 < vaddr1) {
146			len2 = len - vaddr2;
147			m->cpus[0]->memory_rw(m->cpus[0], mem, vaddr,
148			&buf[0], len2, MEM_WRITE, NO_EXCEPTIONS);
149			}
150			m->cpus[0]->memory_rw(m->cpus[0], mem, vaddr + len2,
151			&buf[len2], len-len2, MEM_WRITE, NO_EXCEPTIONS);
152			} else {
153			if (flags & AOUT_FLAG_DECOSF1)
154			break;
155			else {
156	dpavlin	40	fprintf(stderr, "could not read from %s,"
157			" wanted to read %i bytes\n", filename,
158			(int) total_len);
159	dpavlin	38	exit(1);
160			}
161			}
162
163			vaddr += len;
164			total_len -= len;
165			}
166
167			if (symbsize != 0) {
168			struct aout_symbol *aout_symbol_ptr;
169			int i, n_symbols;
170			uint32_t type, addr, str_index;
171			uint32_t strings_len;
172			char *string_symbols;
173			off_t oldpos;
174
175			debug("symbols: %i bytes @ 0x%x\n", symbsize, (int)ftello(f));
176			syms = malloc(symbsize);
177			if (syms == NULL) {
178			fprintf(stderr, "out of memory\n");
179			exit(1);
180			}
181			len = fread(syms, 1, symbsize, f);
182			if (len != symbsize) {
183			fprintf(stderr, "error reading symbols from %s\n",
184			filename);
185			exit(1);
186			}
187
188			oldpos = ftello(f);
189			fseek(f, 0, SEEK_END);
190			strings_len = ftello(f) - oldpos;
191			fseek(f, oldpos, SEEK_SET);
192			debug("strings: %i bytes @ 0x%x\n", strings_len,(int)ftello(f));
193			string_symbols = malloc(strings_len);
194			if (string_symbols == NULL) {
195			fprintf(stderr, "out of memory\n");
196			exit(1);
197			}
198			fread(string_symbols, 1, strings_len, f);
199
200			aout_symbol_ptr = (struct aout_symbol *) syms;
201			n_symbols = symbsize / sizeof(struct aout_symbol);
202			i = 0;
203			while (i < n_symbols) {
204			unencode(str_index, &aout_symbol_ptr[i].strindex,
205			uint32_t);
206			unencode(type, &aout_symbol_ptr[i].type, uint32_t);
207			unencode(addr, &aout_symbol_ptr[i].addr, uint32_t);
208
209			/* debug("symbol type 0x%04x @ 0x%08x: %s\n",
210			type, addr, string_symbols + str_index); */
211
212			if (type != 0 && addr != 0)
213			add_symbol_name(&m->symbol_context,
214			addr, 0, string_symbols + str_index, 0, -1);
215			i++;
216			}
217
218			free(string_symbols);
219			free(syms);
220			}
221
222			fclose(f);
223
224			*entrypointp = (int32_t)entry;
225
226			if (encoding == ELFDATA2LSB)
227			*byte_orderp = EMUL_LITTLE_ENDIAN;
228			else
229			*byte_orderp = EMUL_BIG_ENDIAN;
230
231			n_executables_loaded ++;
232			}
233