Annotation of src/usr.bin/elf2aout/elf2aout.c, Revision 1.1.1.1
1.1 graichen 1: /*
2: * Copyright (c) 1995
3: * Ted Lemon (hereinafter referred to as the author)
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. The name of the author may not be used to endorse or promote products
14: * derived from this software without specific prior written permission.
15: *
16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
17: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE
20: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26: * SUCH DAMAGE.
27: */
28:
29: #include <sys/types.h>
30: #include <fcntl.h>
31: #include <unistd.h>
32: #include <elf_abi.h>
33: #include <machine/elf_abi.h>
34: #include <stdio.h>
35: #include <a.out.h>
36: #include <sys/errno.h>
37: #include <string.h>
38: #include <limits.h>
39:
40: #define SHN_MIPS_ACOMMON 0xfff0
41:
42: extern char *__progname;
43:
44: struct sect {
45: unsigned long vaddr;
46: unsigned long len;
47: };
48: int phcmp ();
49: char *saveRead (int file, off_t offset, off_t len, char *name);
50: int copy (int, int, off_t, off_t);
51: int translate_syms (int, int, off_t, off_t, off_t, off_t);
52: extern int errno;
53: int *symTypeTable;
54:
55: /* Symbol table entry... */
56: struct sym {
57: unsigned long name; /* Index into strtab of symbol name. */
58: unsigned long value; /* Section offset, virt addr or common align. */
59: unsigned long size; /* Size of object referenced. */
60: unsigned type : 4; /* Symbol type (e.g., function, data)... */
61: unsigned binding : 4; /* Symbol binding (e.g., global, local)... */
62: unsigned char other; /* Unused. */
63: unsigned short shndx; /* Section containing symbol. */
64: };
65:
66: struct phdr {
67: unsigned long type; /* Segment type... */
68: unsigned long offset; /* File offset... */
69: unsigned long vaddr; /* Virtual address... */
70: unsigned long paddr; /* Physical address... */
71: unsigned long filesz; /* Size of segment in file... */
72: unsigned long memsz; /* Size of segment in memory... */
73: unsigned long flags; /* Segment flags... */
74: unsigned long align; /* Alighment, file and memory... */
75: };
76:
77: main (int argc, char **argv, char **envp)
78: {
79: Elf32_Ehdr ex;
80: Elf32_Phdr *ph;
81: Elf32_Shdr *sh;
82: struct sym *symtab;
83: char *shstrtab;
84: int strtabix, symtabix;
85: int i;
86: struct sect text, data, bss;
87: struct exec aex;
88: int infile, outfile;
89: unsigned long cur_vma = ULONG_MAX;
90: int symflag = 0;
91:
92: text.len = data.len = bss.len = 0;
93: text.vaddr = data.vaddr = bss.vaddr = 0;
94:
95: /* Check args... */
96: if (argc < 3 || argc > 4)
97: {
98: usage:
99: fprintf (stderr,
100: "usage: %s <elf executable> <a.out executable>\n", __progname);
101: exit (1);
102: }
103:
104: /* Try the input file... */
105: if ((infile = open (argv [1], O_RDONLY)) < 0)
106: {
107: fprintf (stderr, "Can't open %s for read: %s\n",
108: argv [1], strerror (errno));
109: exit (1);
110: }
111:
112: /* Read the header, which is at the beginning of the file... */
113: i = read (infile, &ex, sizeof ex);
114: if (i != sizeof ex)
115: {
116: fprintf (stderr, "ex: %s: %s.\n",
117: argv [1], i ? strerror (errno) : "End of file reached");
118: exit (1);
119: }
120:
121: /* Read the program headers... */
122: ph = (Elf32_Phdr *)saveRead (infile, ex.e_phoff,
123: ex.e_phnum * sizeof (Elf32_Phdr), "ph");
124: /* Read the section headers... */
125: sh = (Elf32_Shdr *)saveRead (infile, ex.e_shoff,
126: ex.e_shnum * sizeof (Elf32_Shdr), "sh");
127: /* Read in the section string table. */
128: shstrtab = saveRead (infile, sh [ex.e_shstrndx].sh_offset,
129: sh [ex.e_shstrndx].sh_size, "shstrtab");
130:
131: /* Find space for a table matching ELF section indices to a.out symbol
132: types. */
133: symTypeTable = (int *)malloc (ex.e_shnum * sizeof (int));
134: if (!symTypeTable)
135: {
136: fprintf (stderr, "symTypeTable: can't allocate.\n");
137: exit (1);
138: }
139: memset (symTypeTable, 0, ex.e_shnum * sizeof (int));
140:
141: /* Look for the symbol table and string table...
142: Also map section indices to symbol types for a.out */
143: for (i = 0; i < ex.e_shnum; i++)
144: {
145: char *name = shstrtab + sh [i].sh_name;
146: if (!strcmp (name, ".symtab"))
147: symtabix = i;
148: else if (!strcmp (name, ".strtab"))
149: strtabix = i;
150: else if (!strcmp (name, ".text") || !strcmp (name, ".rodata"))
151: symTypeTable [i] = N_TEXT;
152: else if (!strcmp (name, ".data") || !strcmp (name, ".sdata") ||
153: !strcmp (name, ".lit4") || !strcmp (name, ".lit8"))
154: symTypeTable [i] = N_DATA;
155: else if (!strcmp (name, ".bss") || !strcmp (name, ".sbss"))
156: symTypeTable [i] = N_BSS;
157: }
158:
159: /* Figure out if we can cram the program header into an a.out header...
160: Basically, we can't handle anything but loadable segments, but we
161: can ignore some kinds of segments. We can't handle holes in the
162: address space, and we handle start addresses other than 0x1000 by
163: hoping that the loader will know where to load - a.out doesn't have
164: an explicit load address. Segments may be out of order, so we
165: sort them first. */
166: qsort (ph, ex.e_phnum, sizeof (Elf32_Phdr), phcmp);
167: for (i = 0; i < ex.e_phnum; i++)
168: {
169: /* Section types we can ignore... */
170: if (ph [i].p_type == PT_NULL || ph [i].p_type == PT_NOTE ||
171: ph [i].p_type == PT_PHDR || ph [i].p_type == PT_MIPS_REGINFO)
172: continue;
173: /* Section types we can't handle... */
174: else if (ph [i].p_type != PT_LOAD)
175: {
176: fprintf (stderr, "Program header %d type %d can't be converted.\n");
177: exit (1);
178: }
179: /* Writable (data) segment? */
180: if (ph [i].p_flags & PF_W)
181: {
182: struct sect ndata, nbss;
183:
184: ndata.vaddr = ph [i].p_vaddr;
185: ndata.len = ph [i].p_filesz;
186: nbss.vaddr = ph [i].p_vaddr + ph [i].p_filesz;
187: nbss.len = ph [i].p_memsz - ph [i].p_filesz;
188:
189: combine (&data, &ndata, 0);
190: combine (&bss, &nbss, 1);
191: }
192: else
193: {
194: struct sect ntxt;
195:
196: ntxt.vaddr = ph [i].p_vaddr;
197: ntxt.len = ph [i].p_filesz;
198:
199: combine (&text, &ntxt);
200: }
201: /* Remember the lowest segment start address. */
202: if (ph [i].p_vaddr < cur_vma)
203: cur_vma = ph [i].p_vaddr;
204: }
205:
206: /* Sections must be in order to be converted... */
207: if (text.vaddr > data.vaddr || data.vaddr > bss.vaddr ||
208: text.vaddr + text.len > data.vaddr || data.vaddr + data.len > bss.vaddr)
209: {
210: fprintf (stderr, "Sections ordering prevents a.out conversion.\n");
211: exit (1);
212: }
213:
214: /* If there's a data section but no text section, then the loader
215: combined everything into one section. That needs to be the
216: text section, so just make the data section zero length following
217: text. */
218: if (data.len && !text.len)
219: {
220: text = data;
221: data.vaddr = text.vaddr + text.len;
222: data.len = 0;
223: }
224:
225: /* If there is a gap between text and data, we'll fill it when we copy
226: the data, so update the length of the text segment as represented in
227: a.out to reflect that, since a.out doesn't allow gaps in the program
228: address space. */
229: if (text.vaddr + text.len < data.vaddr)
230: text.len = data.vaddr - text.vaddr;
231:
232: /* We now have enough information to cons up an a.out header... */
233: aex.a_midmag = htonl ((symflag << 26) | (MID_PMAX << 16) | OMAGIC);
234: aex.a_text = text.len;
235: aex.a_data = data.len;
236: aex.a_bss = bss.len;
237: aex.a_entry = ex.e_entry;
238: aex.a_syms = (sizeof (struct nlist) *
239: (symtabix != -1
240: ? sh [symtabix].sh_size / sizeof (struct sym) : 0));
241: aex.a_trsize = 0;
242: aex.a_drsize = 0;
243:
244: /* Make the output file... */
245: if ((outfile = open (argv [2], O_WRONLY | O_CREAT, 0777)) < 0)
246: {
247: fprintf (stderr, "Unable to create %s: %s\n", argv [2], strerror (errno));
248: exit (1);
249: }
250: /* Write the header... */
251: i = write (outfile, &aex, sizeof aex);
252: if (i != sizeof aex)
253: {
254: perror ("aex: write");
255: exit (1);
256: }
257:
258: /* Copy the loadable sections. Zero-fill any gaps less than 64k;
259: complain about any zero-filling, and die if we're asked to zero-fill
260: more than 64k. */
261: for (i = 0; i < ex.e_phnum; i++)
262: {
263: /* Unprocessable sections were handled above, so just verify that
264: the section can be loaded before copying. */
265: if (ph [i].p_type == PT_LOAD && ph [i].p_filesz)
266: {
267: if (cur_vma != ph [i].p_vaddr)
268: {
269: unsigned long gap = ph [i].p_vaddr - cur_vma;
270: char obuf [1024];
271: if (gap > 65536)
272: {
273: fprintf (stderr, "Intersegment gap (%d bytes) too large.\n",
274: gap);
275: exit (1);
276: }
277: fprintf (stderr, "Warning: %d byte intersegment gap.\n", gap);
278: memset (obuf, 0, sizeof obuf);
279: while (gap)
280: {
281: int count = write (outfile, obuf, (gap > sizeof obuf
282: ? sizeof obuf : gap));
283: if (count < 0)
284: {
285: fprintf (stderr, "Error writing gap: %s\n",
286: strerror (errno));
287: exit (1);
288: }
289: gap -= count;
290: }
291: }
292: copy (outfile, infile, ph [i].p_offset, ph [i].p_filesz);
293: cur_vma = ph [i].p_vaddr + ph [i].p_filesz;
294: }
295: }
296:
297: /* Copy and translate the symbol table... */
298: translate_syms (outfile, infile, sh [symtabix].sh_offset,
299: sh [symtabix].sh_size,
300: sh [strtabix].sh_offset, sh [strtabix].sh_size);
301:
302: /* Looks like we won... */
303: exit (0);
304: }
305:
306: /* translate_syms (out, in, offset, size)
307:
308: Read the ELF symbol table from in at offset; translate it into a.out
309: nlist format and write it to out. */
310:
311: translate_syms (out, in, symoff, symsize, stroff, strsize)
312: int out, in;
313: off_t symoff, symsize;
314: off_t stroff, strsize;
315: {
316: # define SYMS_PER_PASS 64
317: struct sym inbuf [64];
318: struct nlist outbuf [64];
319: int i, remaining, cur;
320: char *oldstrings;
321: char *newstrings, *nsp;
322: int newstringsize;
323:
324: /* Zero the unused fields in the output buffer.. */
325: memset (outbuf, 0, sizeof outbuf);
326:
327: /* Find number of symbols to process... */
328: remaining = symsize / sizeof (struct sym);
329:
330: /* Suck in the old string table... */
331: oldstrings = saveRead (in, stroff, strsize, "string table");
332:
333: /* Allocate space for the new one. XXX We make the wild assumption that
334: no two symbol table entries will point at the same place in the
335: string table - if that assumption is bad, this could easily blow up. */
336: newstringsize = strsize + remaining;
337: newstrings = (char *)malloc (newstringsize);
338: if (!newstrings)
339: {
340: fprintf (stderr, "No memory for new string table!\n");
341: exit (1);
342: }
343: /* Initialize the table pointer... */
344: nsp = newstrings;
345:
346: /* Go the the start of the ELF symbol table... */
347: if (lseek (in, symoff, SEEK_SET) < 0)
348: {
349: perror ("translate_syms: lseek");
350: exit (1);
351: }
352:
353: /* Translate and copy symbols... */
354: while (remaining)
355: {
356: cur = remaining;
357: if (cur > SYMS_PER_PASS)
358: cur = SYMS_PER_PASS;
359: remaining -= cur;
360: if ((i = read (in, inbuf, cur * sizeof (struct sym)))
361: != cur * sizeof (struct sym))
362: {
363: if (i < 0)
364: perror ("translate_syms");
365: else
366: fprintf (stderr, "translate_syms: premature end of file.\n");
367: exit (1);
368: }
369:
370: /* Do the translation... */
371: for (i = 0; i < cur; i++)
372: {
373: /* Copy the symbol into the new table, but prepend an underscore. */
374: *nsp = '_';
375: strcpy (nsp + 1, oldstrings + inbuf [i].name);
376: outbuf [i].n_un.n_strx = nsp - newstrings + 4;
377: nsp += strlen (nsp) + 1;
378:
379: /* Convert ELF symbol type/section/etc info into a.out type info. */
380: if (inbuf [i].type == STT_FILE)
381: outbuf [i].n_type = N_FN;
382: else if (inbuf [i].shndx == SHN_UNDEF)
383: outbuf [i].n_type = N_UNDF;
384: else if (inbuf [i].shndx == SHN_ABS)
385: outbuf [i].n_type = N_ABS;
386: else if (inbuf [i].shndx == SHN_COMMON ||
387: inbuf [i].shndx == SHN_MIPS_ACOMMON)
388: outbuf [i].n_type = N_COMM;
389: else
390: outbuf [i].n_type = symTypeTable [inbuf [i].shndx];
391: if (inbuf [i].binding == STB_GLOBAL)
392: outbuf [i].n_type |= N_EXT;
393: /* Symbol values in executables should be compatible. */
394: outbuf [i].n_value = inbuf [i].value;
395: }
396: /* Write out the symbols... */
397: if ((i = write (out, outbuf, cur * sizeof (struct nlist)))
398: != cur * sizeof (struct nlist))
399: {
400: fprintf (stderr, "translate_syms: write: %s\n", strerror (errno));
401: exit (1);
402: }
403: }
404: /* Write out the string table length... */
405: if (write (out, &newstringsize, sizeof newstringsize)
406: != sizeof newstringsize)
407: {
408: fprintf (stderr,
409: "translate_syms: newstringsize: %s\n", strerror (errno));
410: exit (1);
411: }
412: /* Write out the string table... */
413: if (write (out, newstrings, newstringsize) != newstringsize)
414: {
415: fprintf (stderr, "translate_syms: newstrings: %s\n", strerror (errno));
416: exit (1);
417: }
418: }
419:
420: copy (out, in, offset, size)
421: int out, in;
422: off_t offset, size;
423: {
424: char ibuf [4096];
425: int remaining, cur, count;
426:
427: /* Go the the start of the ELF symbol table... */
428: if (lseek (in, offset, SEEK_SET) < 0)
429: {
430: perror ("copy: lseek");
431: exit (1);
432: }
433:
434: remaining = size;
435: while (remaining)
436: {
437: cur = remaining;
438: if (cur > sizeof ibuf)
439: cur = sizeof ibuf;
440: remaining -= cur;
441: if ((count = read (in, ibuf, cur)) != cur)
442: {
443: fprintf (stderr, "copy: read: %s\n",
444: count ? strerror (errno) : "premature end of file");
445: exit (1);
446: }
447: if ((count = write (out, ibuf, cur)) != cur)
448: {
449: perror ("copy: write");
450: exit (1);
451: }
452: }
453: }
454:
455: /* Combine two segments, which must be contiguous. If pad is true, it's
456: okay for there to be padding between. */
457: combine (base, new, pad)
458: struct sect *base, *new;
459: int pad;
460: {
461: if (!base -> len)
462: *base = *new;
463: else if (new -> len)
464: {
465: if (base -> vaddr + base -> len != new -> vaddr)
466: {
467: if (pad)
468: base -> len = new -> vaddr - base -> vaddr;
469: else
470: {
471: fprintf (stderr,
472: "Non-contiguous data can't be converted.\n");
473: exit (1);
474: }
475: }
476: base -> len += new -> len;
477: }
478: }
479:
480: phcmp (h1, h2)
481: struct phdr *h1, *h2;
482: {
483: if (h1 -> vaddr > h2 -> vaddr)
484: return 1;
485: else if (h1 -> vaddr < h2 -> vaddr)
486: return -1;
487: else
488: return 0;
489: }
490:
491: char *saveRead (int file, off_t offset, off_t len, char *name)
492: {
493: char *tmp;
494: int count;
495: off_t off;
496: if ((off = lseek (file, offset, SEEK_SET)) < 0)
497: {
498: fprintf (stderr, "%s: fseek: %s\n", name, strerror (errno));
499: exit (1);
500: }
501: if (!(tmp = (char *)malloc (len)))
502: {
503: fprintf (stderr, "%s: Can't allocate %d bytes.\n", name, len);
504: exit (1);
505: }
506: count = read (file, tmp, len);
507: if (count != len)
508: {
509: fprintf (stderr, "%s: read: %s.\n",
510: name, count ? strerror (errno) : "End of file reached");
511: exit (1);
512: }
513: return tmp;
514: }
![[BACK]](/icons/back.gif){kind=icon}
Return to elf2aout.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / elf2aout