xref: /openbmc/linux/arch/mips/boot/elf2ecoff.c (revision d7a3d85e) 
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 /* elf2ecoff.c
30 
31    This program converts an elf executable to an ECOFF executable.
32    No symbol table is retained.	  This is useful primarily in building
33    net-bootable kernels for machines (e.g., DECstation and Alpha) which
34    only support the ECOFF object file format. */
35 
36 #include <stdio.h>
37 #include <string.h>
38 #include <errno.h>
39 #include <sys/types.h>
40 #include <fcntl.h>
41 #include <unistd.h>
42 #include <elf.h>
43 #include <limits.h>
44 #include <netinet/in.h>
45 #include <stdlib.h>
46 
47 #include "ecoff.h"
48 
49 /*
50  * Some extra ELF definitions
51  */
52 #define PT_MIPS_REGINFO 	0x70000000	/* Register usage information */
53 #define PT_MIPS_ABIFLAGS	0x70000003	/* Records ABI related flags  */
54 
55 /* -------------------------------------------------------------------- */
56 
57 struct sect {
58 	unsigned long vaddr;
59 	unsigned long len;
60 };
61 
62 int *symTypeTable;
63 int must_convert_endian;
64 int format_bigendian;
65 
66 static void copy(int out, int in, off_t offset, off_t size)
67 {
68 	char ibuf[4096];
69 	int remaining, cur, count;
70 
71 	/* Go to the start of the ELF symbol table... */
72 	if (lseek(in, offset, SEEK_SET) < 0) {
73 		perror("copy: lseek");
74 		exit(1);
75 	}
76 
77 	remaining = size;
78 	while (remaining) {
79 		cur = remaining;
80 		if (cur > sizeof ibuf)
81 			cur = sizeof ibuf;
82 		remaining -= cur;
83 		if ((count = read(in, ibuf, cur)) != cur) {
84 			fprintf(stderr, "copy: read: %s\n",
85 				count ? strerror(errno) :
86 				"premature end of file");
87 			exit(1);
88 		}
89 		if ((count = write(out, ibuf, cur)) != cur) {
90 			perror("copy: write");
91 			exit(1);
92 		}
93 	}
94 }
95 
96 /*
97  * Combine two segments, which must be contiguous.   If pad is true, it's
98  * okay for there to be padding between.
99  */
100 static void combine(struct sect *base, struct sect *new, int pad)
101 {
102 	if (!base->len)
103 		*base = *new;
104 	else if (new->len) {
105 		if (base->vaddr + base->len != new->vaddr) {
106 			if (pad)
107 				base->len = new->vaddr - base->vaddr;
108 			else {
109 				fprintf(stderr,
110 					"Non-contiguous data can't be converted.\n");
111 				exit(1);
112 			}
113 		}
114 		base->len += new->len;
115 	}
116 }
117 
118 static int phcmp(const void *v1, const void *v2)
119 {
120 	const Elf32_Phdr *h1 = v1;
121 	const Elf32_Phdr *h2 = v2;
122 
123 	if (h1->p_vaddr > h2->p_vaddr)
124 		return 1;
125 	else if (h1->p_vaddr < h2->p_vaddr)
126 		return -1;
127 	else
128 		return 0;
129 }
130 
131 static char *saveRead(int file, off_t offset, off_t len, char *name)
132 {
133 	char *tmp;
134 	int count;
135 	off_t off;
136 	if ((off = lseek(file, offset, SEEK_SET)) < 0) {
137 		fprintf(stderr, "%s: fseek: %s\n", name, strerror(errno));
138 		exit(1);
139 	}
140 	if (!(tmp = (char *) malloc(len))) {
141 		fprintf(stderr, "%s: Can't allocate %ld bytes.\n", name,
142 			len);
143 		exit(1);
144 	}
145 	count = read(file, tmp, len);
146 	if (count != len) {
147 		fprintf(stderr, "%s: read: %s.\n",
148 			name,
149 			count ? strerror(errno) : "End of file reached");
150 		exit(1);
151 	}
152 	return tmp;
153 }
154 
155 #define swab16(x) \
156 	((unsigned short)( \
157 		(((unsigned short)(x) & (unsigned short)0x00ffU) << 8) | \
158 		(((unsigned short)(x) & (unsigned short)0xff00U) >> 8) ))
159 
160 #define swab32(x) \
161 	((unsigned int)( \
162 		(((unsigned int)(x) & (unsigned int)0x000000ffUL) << 24) | \
163 		(((unsigned int)(x) & (unsigned int)0x0000ff00UL) <<  8) | \
164 		(((unsigned int)(x) & (unsigned int)0x00ff0000UL) >>  8) | \
165 		(((unsigned int)(x) & (unsigned int)0xff000000UL) >> 24) ))
166 
167 static void convert_elf_hdr(Elf32_Ehdr * e)
168 {
169 	e->e_type = swab16(e->e_type);
170 	e->e_machine = swab16(e->e_machine);
171 	e->e_version = swab32(e->e_version);
172 	e->e_entry = swab32(e->e_entry);
173 	e->e_phoff = swab32(e->e_phoff);
174 	e->e_shoff = swab32(e->e_shoff);
175 	e->e_flags = swab32(e->e_flags);
176 	e->e_ehsize = swab16(e->e_ehsize);
177 	e->e_phentsize = swab16(e->e_phentsize);
178 	e->e_phnum = swab16(e->e_phnum);
179 	e->e_shentsize = swab16(e->e_shentsize);
180 	e->e_shnum = swab16(e->e_shnum);
181 	e->e_shstrndx = swab16(e->e_shstrndx);
182 }
183 
184 static void convert_elf_phdrs(Elf32_Phdr * p, int num)
185 {
186 	int i;
187 
188 	for (i = 0; i < num; i++, p++) {
189 		p->p_type = swab32(p->p_type);
190 		p->p_offset = swab32(p->p_offset);
191 		p->p_vaddr = swab32(p->p_vaddr);
192 		p->p_paddr = swab32(p->p_paddr);
193 		p->p_filesz = swab32(p->p_filesz);
194 		p->p_memsz = swab32(p->p_memsz);
195 		p->p_flags = swab32(p->p_flags);
196 		p->p_align = swab32(p->p_align);
197 	}
198 
199 }
200 
201 static void convert_elf_shdrs(Elf32_Shdr * s, int num)
202 {
203 	int i;
204 
205 	for (i = 0; i < num; i++, s++) {
206 		s->sh_name = swab32(s->sh_name);
207 		s->sh_type = swab32(s->sh_type);
208 		s->sh_flags = swab32(s->sh_flags);
209 		s->sh_addr = swab32(s->sh_addr);
210 		s->sh_offset = swab32(s->sh_offset);
211 		s->sh_size = swab32(s->sh_size);
212 		s->sh_link = swab32(s->sh_link);
213 		s->sh_info = swab32(s->sh_info);
214 		s->sh_addralign = swab32(s->sh_addralign);
215 		s->sh_entsize = swab32(s->sh_entsize);
216 	}
217 }
218 
219 static void convert_ecoff_filehdr(struct filehdr *f)
220 {
221 	f->f_magic = swab16(f->f_magic);
222 	f->f_nscns = swab16(f->f_nscns);
223 	f->f_timdat = swab32(f->f_timdat);
224 	f->f_symptr = swab32(f->f_symptr);
225 	f->f_nsyms = swab32(f->f_nsyms);
226 	f->f_opthdr = swab16(f->f_opthdr);
227 	f->f_flags = swab16(f->f_flags);
228 }
229 
230 static void convert_ecoff_aouthdr(struct aouthdr *a)
231 {
232 	a->magic = swab16(a->magic);
233 	a->vstamp = swab16(a->vstamp);
234 	a->tsize = swab32(a->tsize);
235 	a->dsize = swab32(a->dsize);
236 	a->bsize = swab32(a->bsize);
237 	a->entry = swab32(a->entry);
238 	a->text_start = swab32(a->text_start);
239 	a->data_start = swab32(a->data_start);
240 	a->bss_start = swab32(a->bss_start);
241 	a->gprmask = swab32(a->gprmask);
242 	a->cprmask[0] = swab32(a->cprmask[0]);
243 	a->cprmask[1] = swab32(a->cprmask[1]);
244 	a->cprmask[2] = swab32(a->cprmask[2]);
245 	a->cprmask[3] = swab32(a->cprmask[3]);
246 	a->gp_value = swab32(a->gp_value);
247 }
248 
249 static void convert_ecoff_esecs(struct scnhdr *s, int num)
250 {
251 	int i;
252 
253 	for (i = 0; i < num; i++, s++) {
254 		s->s_paddr = swab32(s->s_paddr);
255 		s->s_vaddr = swab32(s->s_vaddr);
256 		s->s_size = swab32(s->s_size);
257 		s->s_scnptr = swab32(s->s_scnptr);
258 		s->s_relptr = swab32(s->s_relptr);
259 		s->s_lnnoptr = swab32(s->s_lnnoptr);
260 		s->s_nreloc = swab16(s->s_nreloc);
261 		s->s_nlnno = swab16(s->s_nlnno);
262 		s->s_flags = swab32(s->s_flags);
263 	}
264 }
265 
266 int main(int argc, char *argv[])
267 {
268 	Elf32_Ehdr ex;
269 	Elf32_Phdr *ph;
270 	Elf32_Shdr *sh;
271 	int i, pad;
272 	struct sect text, data, bss;
273 	struct filehdr efh;
274 	struct aouthdr eah;
275 	struct scnhdr esecs[6];
276 	int infile, outfile;
277 	unsigned long cur_vma = ULONG_MAX;
278 	int addflag = 0;
279 	int nosecs;
280 
281 	text.len = data.len = bss.len = 0;
282 	text.vaddr = data.vaddr = bss.vaddr = 0;
283 
284 	/* Check args... */
285 	if (argc < 3 || argc > 4) {
286 	      usage:
287 		fprintf(stderr,
288 			"usage: elf2ecoff <elf executable> <ecoff executable> [-a]\n");
289 		exit(1);
290 	}
291 	if (argc == 4) {
292 		if (strcmp(argv[3], "-a"))
293 			goto usage;
294 		addflag = 1;
295 	}
296 
297 	/* Try the input file... */
298 	if ((infile = open(argv[1], O_RDONLY)) < 0) {
299 		fprintf(stderr, "Can't open %s for read: %s\n",
300 			argv[1], strerror(errno));
301 		exit(1);
302 	}
303 
304 	/* Read the header, which is at the beginning of the file... */
305 	i = read(infile, &ex, sizeof ex);
306 	if (i != sizeof ex) {
307 		fprintf(stderr, "ex: %s: %s.\n",
308 			argv[1],
309 			i ? strerror(errno) : "End of file reached");
310 		exit(1);
311 	}
312 
313 	if (ex.e_ident[EI_DATA] == ELFDATA2MSB)
314 		format_bigendian = 1;
315 
316 	if (ntohs(0xaa55) == 0xaa55) {
317 		if (!format_bigendian)
318 			must_convert_endian = 1;
319 	} else {
320 		if (format_bigendian)
321 			must_convert_endian = 1;
322 	}
323 	if (must_convert_endian)
324 		convert_elf_hdr(&ex);
325 
326 	/* Read the program headers... */
327 	ph = (Elf32_Phdr *) saveRead(infile, ex.e_phoff,
328 				     ex.e_phnum * sizeof(Elf32_Phdr),
329 				     "ph");
330 	if (must_convert_endian)
331 		convert_elf_phdrs(ph, ex.e_phnum);
332 	/* Read the section headers... */
333 	sh = (Elf32_Shdr *) saveRead(infile, ex.e_shoff,
334 				     ex.e_shnum * sizeof(Elf32_Shdr),
335 				     "sh");
336 	if (must_convert_endian)
337 		convert_elf_shdrs(sh, ex.e_shnum);
338 
339 	/* Figure out if we can cram the program header into an ECOFF
340 	   header...  Basically, we can't handle anything but loadable
341 	   segments, but we can ignore some kinds of segments.	We can't
342 	   handle holes in the address space.  Segments may be out of order,
343 	   so we sort them first. */
344 
345 	qsort(ph, ex.e_phnum, sizeof(Elf32_Phdr), phcmp);
346 
347 	for (i = 0; i < ex.e_phnum; i++) {
348 		/* Section types we can ignore... */
349 		switch (ph[i].p_type) {
350 		case PT_NULL:
351 		case PT_NOTE:
352 		case PT_PHDR:
353 		case PT_MIPS_REGINFO:
354 		case PT_MIPS_ABIFLAGS:
355 			continue;
356 
357 		case PT_LOAD:
358 			/* Writable (data) segment? */
359 			if (ph[i].p_flags & PF_W) {
360 				struct sect ndata, nbss;
361 
362 				ndata.vaddr = ph[i].p_vaddr;
363 				ndata.len = ph[i].p_filesz;
364 				nbss.vaddr = ph[i].p_vaddr + ph[i].p_filesz;
365 				nbss.len = ph[i].p_memsz - ph[i].p_filesz;
366 
367 				combine(&data, &ndata, 0);
368 				combine(&bss, &nbss, 1);
369 			} else {
370 				struct sect ntxt;
371 
372 				ntxt.vaddr = ph[i].p_vaddr;
373 				ntxt.len = ph[i].p_filesz;
374 
375 				combine(&text, &ntxt, 0);
376 			}
377 			/* Remember the lowest segment start address. */
378 			if (ph[i].p_vaddr < cur_vma)
379 				cur_vma = ph[i].p_vaddr;
380 			break;
381 
382 		default:
383 			/* Section types we can't handle... */
384 			fprintf(stderr,
385 				"Program header %d type %d can't be converted.\n",
386 				ex.e_phnum, ph[i].p_type);
387 			exit(1);
388 		}
389 	}
390 
391 	/* Sections must be in order to be converted... */
392 	if (text.vaddr > data.vaddr || data.vaddr > bss.vaddr ||
393 	    text.vaddr + text.len > data.vaddr
394 	    || data.vaddr + data.len > bss.vaddr) {
395 		fprintf(stderr,
396 			"Sections ordering prevents a.out conversion.\n");
397 		exit(1);
398 	}
399 
400 	/* If there's a data section but no text section, then the loader
401 	   combined everything into one section.   That needs to be the
402 	   text section, so just make the data section zero length following
403 	   text. */
404 	if (data.len && !text.len) {
405 		text = data;
406 		data.vaddr = text.vaddr + text.len;
407 		data.len = 0;
408 	}
409 
410 	/* If there is a gap between text and data, we'll fill it when we copy
411 	   the data, so update the length of the text segment as represented in
412 	   a.out to reflect that, since a.out doesn't allow gaps in the program
413 	   address space. */
414 	if (text.vaddr + text.len < data.vaddr)
415 		text.len = data.vaddr - text.vaddr;
416 
417 	/* We now have enough information to cons up an a.out header... */
418 	eah.magic = OMAGIC;
419 	eah.vstamp = 200;
420 	eah.tsize = text.len;
421 	eah.dsize = data.len;
422 	eah.bsize = bss.len;
423 	eah.entry = ex.e_entry;
424 	eah.text_start = text.vaddr;
425 	eah.data_start = data.vaddr;
426 	eah.bss_start = bss.vaddr;
427 	eah.gprmask = 0xf3fffffe;
428 	memset(&eah.cprmask, '\0', sizeof eah.cprmask);
429 	eah.gp_value = 0;	/* unused. */
430 
431 	if (format_bigendian)
432 		efh.f_magic = MIPSEBMAGIC;
433 	else
434 		efh.f_magic = MIPSELMAGIC;
435 	if (addflag)
436 		nosecs = 6;
437 	else
438 		nosecs = 3;
439 	efh.f_nscns = nosecs;
440 	efh.f_timdat = 0;	/* bogus */
441 	efh.f_symptr = 0;
442 	efh.f_nsyms = 0;
443 	efh.f_opthdr = sizeof eah;
444 	efh.f_flags = 0x100f;	/* Stripped, not sharable. */
445 
446 	memset(esecs, 0, sizeof esecs);
447 	strcpy(esecs[0].s_name, ".text");
448 	strcpy(esecs[1].s_name, ".data");
449 	strcpy(esecs[2].s_name, ".bss");
450 	if (addflag) {
451 		strcpy(esecs[3].s_name, ".rdata");
452 		strcpy(esecs[4].s_name, ".sdata");
453 		strcpy(esecs[5].s_name, ".sbss");
454 	}
455 	esecs[0].s_paddr = esecs[0].s_vaddr = eah.text_start;
456 	esecs[1].s_paddr = esecs[1].s_vaddr = eah.data_start;
457 	esecs[2].s_paddr = esecs[2].s_vaddr = eah.bss_start;
458 	if (addflag) {
459 		esecs[3].s_paddr = esecs[3].s_vaddr = 0;
460 		esecs[4].s_paddr = esecs[4].s_vaddr = 0;
461 		esecs[5].s_paddr = esecs[5].s_vaddr = 0;
462 	}
463 	esecs[0].s_size = eah.tsize;
464 	esecs[1].s_size = eah.dsize;
465 	esecs[2].s_size = eah.bsize;
466 	if (addflag) {
467 		esecs[3].s_size = 0;
468 		esecs[4].s_size = 0;
469 		esecs[5].s_size = 0;
470 	}
471 	esecs[0].s_scnptr = N_TXTOFF(efh, eah);
472 	esecs[1].s_scnptr = N_DATOFF(efh, eah);
473 #define ECOFF_SEGMENT_ALIGNMENT(a) 0x10
474 #define ECOFF_ROUND(s, a) (((s)+(a)-1)&~((a)-1))
475 	esecs[2].s_scnptr = esecs[1].s_scnptr +
476 	    ECOFF_ROUND(esecs[1].s_size, ECOFF_SEGMENT_ALIGNMENT(&eah));
477 	if (addflag) {
478 		esecs[3].s_scnptr = 0;
479 		esecs[4].s_scnptr = 0;
480 		esecs[5].s_scnptr = 0;
481 	}
482 	esecs[0].s_relptr = esecs[1].s_relptr = esecs[2].s_relptr = 0;
483 	esecs[0].s_lnnoptr = esecs[1].s_lnnoptr = esecs[2].s_lnnoptr = 0;
484 	esecs[0].s_nreloc = esecs[1].s_nreloc = esecs[2].s_nreloc = 0;
485 	esecs[0].s_nlnno = esecs[1].s_nlnno = esecs[2].s_nlnno = 0;
486 	if (addflag) {
487 		esecs[3].s_relptr = esecs[4].s_relptr
488 		    = esecs[5].s_relptr = 0;
489 		esecs[3].s_lnnoptr = esecs[4].s_lnnoptr
490 		    = esecs[5].s_lnnoptr = 0;
491 		esecs[3].s_nreloc = esecs[4].s_nreloc = esecs[5].s_nreloc =
492 		    0;
493 		esecs[3].s_nlnno = esecs[4].s_nlnno = esecs[5].s_nlnno = 0;
494 	}
495 	esecs[0].s_flags = 0x20;
496 	esecs[1].s_flags = 0x40;
497 	esecs[2].s_flags = 0x82;
498 	if (addflag) {
499 		esecs[3].s_flags = 0x100;
500 		esecs[4].s_flags = 0x200;
501 		esecs[5].s_flags = 0x400;
502 	}
503 
504 	/* Make the output file... */
505 	if ((outfile = open(argv[2], O_WRONLY | O_CREAT, 0777)) < 0) {
506 		fprintf(stderr, "Unable to create %s: %s\n", argv[2],
507 			strerror(errno));
508 		exit(1);
509 	}
510 
511 	if (must_convert_endian)
512 		convert_ecoff_filehdr(&efh);
513 	/* Write the headers... */
514 	i = write(outfile, &efh, sizeof efh);
515 	if (i != sizeof efh) {
516 		perror("efh: write");
517 		exit(1);
518 
519 		for (i = 0; i < nosecs; i++) {
520 			printf
521 			    ("Section %d: %s phys %lx  size %lx	 file offset %lx\n",
522 			     i, esecs[i].s_name, esecs[i].s_paddr,
523 			     esecs[i].s_size, esecs[i].s_scnptr);
524 		}
525 	}
526 	fprintf(stderr, "wrote %d byte file header.\n", i);
527 
528 	if (must_convert_endian)
529 		convert_ecoff_aouthdr(&eah);
530 	i = write(outfile, &eah, sizeof eah);
531 	if (i != sizeof eah) {
532 		perror("eah: write");
533 		exit(1);
534 	}
535 	fprintf(stderr, "wrote %d byte a.out header.\n", i);
536 
537 	if (must_convert_endian)
538 		convert_ecoff_esecs(&esecs[0], nosecs);
539 	i = write(outfile, &esecs, nosecs * sizeof(struct scnhdr));
540 	if (i != nosecs * sizeof(struct scnhdr)) {
541 		perror("esecs: write");
542 		exit(1);
543 	}
544 	fprintf(stderr, "wrote %d bytes of section headers.\n", i);
545 
546 	pad = (sizeof(efh) + sizeof(eah) + nosecs * sizeof(struct scnhdr)) & 15;
547 	if (pad) {
548 		pad = 16 - pad;
549 		i = write(outfile, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0", pad);
550 		if (i < 0) {
551 			perror("ipad: write");
552 			exit(1);
553 		}
554 		fprintf(stderr, "wrote %d byte pad.\n", i);
555 	}
556 
557 	/*
558 	 * Copy the loadable sections.	 Zero-fill any gaps less than 64k;
559 	 * complain about any zero-filling, and die if we're asked to zero-fill
560 	 * more than 64k.
561 	 */
562 	for (i = 0; i < ex.e_phnum; i++) {
563 		/* Unprocessable sections were handled above, so just verify that
564 		   the section can be loaded before copying. */
565 		if (ph[i].p_type == PT_LOAD && ph[i].p_filesz) {
566 			if (cur_vma != ph[i].p_vaddr) {
567 				unsigned long gap =
568 				    ph[i].p_vaddr - cur_vma;
569 				char obuf[1024];
570 				if (gap > 65536) {
571 					fprintf(stderr,
572 						"Intersegment gap (%ld bytes) too large.\n",
573 						gap);
574 					exit(1);
575 				}
576 				fprintf(stderr,
577 					"Warning: %ld byte intersegment gap.\n",
578 					gap);
579 				memset(obuf, 0, sizeof obuf);
580 				while (gap) {
581 					int count =
582 					    write(outfile, obuf,
583 						  (gap >
584 						   sizeof obuf ? sizeof
585 						   obuf : gap));
586 					if (count < 0) {
587 						fprintf(stderr,
588 							"Error writing gap: %s\n",
589 							strerror(errno));
590 						exit(1);
591 					}
592 					gap -= count;
593 				}
594 			}
595 			fprintf(stderr, "writing %d bytes...\n",
596 				ph[i].p_filesz);
597 			copy(outfile, infile, ph[i].p_offset,
598 			     ph[i].p_filesz);
599 			cur_vma = ph[i].p_vaddr + ph[i].p_filesz;
600 		}
601 	}
602 
603 	/*
604 	 * Write a page of padding for boot PROMS that read entire pages.
605 	 * Without this, they may attempt to read past the end of the
606 	 * data section, incur an error, and refuse to boot.
607 	 */
608 	{
609 		char obuf[4096];
610 		memset(obuf, 0, sizeof obuf);
611 		if (write(outfile, obuf, sizeof(obuf)) != sizeof(obuf)) {
612 			fprintf(stderr, "Error writing PROM padding: %s\n",
613 				strerror(errno));
614 			exit(1);
615 		}
616 	}
617 
618 	/* Looks like we won... */
619 	exit(0);
620 }
621