1 #include <lib9.h>
2 #include <bio.h>
3 #include "bootexec.h"
4 #include "mach.h"
5 #include "elf.h"
6
7 /*
8 * All a.out header types. The dummy entry allows canonical
9 * processing of the union as a sequence of longs
10 */
11
12 typedef struct {
13 union{
14 Exec exec;
15 struct {
16 u32int ohdr[8]; /* Exec */
17 uvlong hdr[1];
18 } exechdr64;
19 Ehdr elfhdr32; /* elf.h */
20 struct mipsexec mips32; /* bootexec.h */
21 struct mips4kexec mips4k; /* bootexec.h */
22 struct sparcexec sparc; /* bootexec.h */
23 struct nextexec next; /* bootexec.h */
24 } e;
25 u32int dummy; /* padding to ensure extra u32int */
26 } ExecHdr;
27
28 static int nextboot(int, Fhdr*, ExecHdr*);
29 static int sparcboot(int, Fhdr*, ExecHdr*);
30 static int mipsboot(int, Fhdr*, ExecHdr*);
31 static int mips4kboot(int, Fhdr*, ExecHdr*);
32 static int common(int, Fhdr*, ExecHdr*);
33 static int commonllp64(int, Fhdr*, ExecHdr*);
34 static int adotout(int, Fhdr*, ExecHdr*);
35 static int elfdotout(int, Fhdr*, ExecHdr*);
36 static int armdotout(int, Fhdr*, ExecHdr*);
37 static void setsym(Fhdr*, long, long, long, vlong);
38 static void setdata(Fhdr*, uvlong, long, vlong, long);
39 static void settext(Fhdr*, uvlong, uvlong, long, vlong);
40 static void hswal(void*, int, ulong(*)(ulong));
41 static uvlong _round(uvlong, ulong);
42
43 /*
44 * definition of per-executable file type structures
45 */
46
47 typedef struct Exectable{
48 long magic; /* big-endian magic number of file */
49 char *name; /* executable identifier */
50 char *dlmname; /* dynamically loadable module identifier */
51 uchar type; /* Internal code */
52 uchar _magic; /* _MAGIC() magic */
53 Mach *mach; /* Per-machine data */
54 long hsize; /* header size */
55 ulong (*swal)(ulong); /* beswal or leswal */
56 int (*hparse)(int, Fhdr*, ExecHdr*);
57 } ExecTable;
58
59 extern Mach mmips;
60 extern Mach mmips2le;
61 extern Mach mmips2be;
62 extern Mach msparc;
63 extern Mach mi386;
64 extern Mach mamd64;
65 extern Mach marm;
66 extern Mach mpower;
67 extern Mach mpower64;
68 extern Mach mriscv;
69 extern Mach mriscv64;
70
71 ExecTable exectab[] =
72 {
73 { V_MAGIC, /* Mips v.out */
74 "mips plan 9 executable BE",
75 "mips plan 9 dlm BE",
76 FMIPS,
77 1,
78 &mmips,
79 sizeof(Exec),
80 beswal,
81 adotout },
82 { P_MAGIC, /* Mips 0.out (r3k le) */
83 "mips plan 9 executable LE",
84 "mips plan 9 dlm LE",
85 FMIPSLE,
86 1,
87 &mmips,
88 sizeof(Exec),
89 beswal,
90 adotout },
91 { M_MAGIC, /* Mips 4.out */
92 "mips 4k plan 9 executable BE",
93 "mips 4k plan 9 dlm BE",
94 FMIPS2BE,
95 1,
96 &mmips2be,
97 sizeof(Exec),
98 beswal,
99 adotout },
100 { N_MAGIC, /* Mips 0.out */
101 "mips 4k plan 9 executable LE",
102 "mips 4k plan 9 dlm LE",
103 FMIPS2LE,
104 1,
105 &mmips2le,
106 sizeof(Exec),
107 beswal,
108 adotout },
109 { 0x160<<16, /* Mips boot image */
110 "mips plan 9 boot image",
111 nil,
112 FMIPSB,
113 0,
114 &mmips,
115 sizeof(struct mipsexec),
116 beswal,
117 mipsboot },
118 { (0x160<<16)|3, /* Mips boot image */
119 "mips 4k plan 9 boot image",
120 nil,
121 FMIPSB,
122 0,
123 &mmips2be,
124 sizeof(struct mips4kexec),
125 beswal,
126 mips4kboot },
127 { K_MAGIC, /* Sparc k.out */
128 "sparc plan 9 executable",
129 "sparc plan 9 dlm",
130 FSPARC,
131 1,
132 &msparc,
133 sizeof(Exec),
134 beswal,
135 adotout },
136 { 0x01030107, /* Sparc boot image */
137 "sparc plan 9 boot image",
138 nil,
139 FSPARCB,
140 0,
141 &msparc,
142 sizeof(struct sparcexec),
143 beswal,
144 sparcboot },
145 { I_MAGIC, /* I386 8.out & boot image */
146 "386 plan 9 executable",
147 "386 plan 9 dlm",
148 FI386,
149 1,
150 &mi386,
151 sizeof(Exec),
152 beswal,
153 common },
154 { S_MAGIC, /* amd64 6.out & boot image */
155 "amd64 plan 9 executable",
156 "amd64 plan 9 dlm",
157 FAMD64,
158 1,
159 &mamd64,
160 sizeof(Exec)+8,
161 nil,
162 commonllp64 },
163 { Q_MAGIC, /* PowerPC q.out & boot image */
164 "power plan 9 executable",
165 "power plan 9 dlm",
166 FPOWER,
167 1,
168 &mpower,
169 sizeof(Exec),
170 beswal,
171 common },
172 { T_MAGIC, /* power64 9.out & boot image */
173 "power64 plan 9 executable",
174 "power64 plan 9 dlm",
175 FPOWER64,
176 1,
177 &mpower64,
178 sizeof(Exec)+8,
179 nil,
180 commonllp64 },
181 { ELF_MAG, /* any elf32 */
182 "elf executable",
183 nil,
184 FNONE,
185 0,
186 &mi386,
187 sizeof(Ehdr),
188 nil,
189 elfdotout },
190 { E_MAGIC, /* Arm 5.out and boot image */
191 "arm plan 9 executable",
192 "arm plan 9 dlm",
193 FARM,
194 1,
195 &marm,
196 sizeof(Exec),
197 beswal,
198 common },
199 { (143<<16)|0413, /* (Free|Net)BSD Arm */
200 "arm *bsd executable",
201 nil,
202 FARM,
203 0,
204 &marm,
205 sizeof(Exec),
206 leswal,
207 armdotout },
208 { Z_MAGIC, /* riscv i.out */
209 "riscv executable",
210 nil,
211 FRISCV,
212 0,
213 &mriscv,
214 sizeof(Exec),
215 beswal,
216 common },
217 { Y_MAGIC, /* riscv j.out */
218 "riscv64 executable",
219 nil,
220 FRISCV64,
221 0,
222 &mriscv64,
223 sizeof(Exec),
224 beswal,
225 common },
226 { 0 },
227 };
228
229 Mach *mach = &mi386; /* Global current machine table */
230
231 static ExecTable*
couldbe4k(ExecTable * mp)232 couldbe4k(ExecTable *mp)
233 {
234 Dir *d;
235 ExecTable *f;
236
237 if((d=dirstat("/proc/1/regs")) == nil)
238 return mp;
239 if(d->length < 32*8){ /* R3000 */
240 free(d);
241 return mp;
242 }
243 free(d);
244 for (f = exectab; f->magic; f++)
245 if(f->magic == M_MAGIC) {
246 f->name = "mips plan 9 executable on mips2 kernel";
247 return f;
248 }
249 return mp;
250 }
251
252 int
crackhdr(int fd,Fhdr * fp)253 crackhdr(int fd, Fhdr *fp)
254 {
255 ExecTable *mp;
256 ExecHdr d;
257 int nb, ret;
258 ulong magic;
259
260 fp->type = FNONE;
261 nb = read(fd, (char *)&d.e, sizeof(d.e));
262 if (nb <= 0)
263 return 0;
264
265 ret = 0;
266 magic = beswal(d.e.exec.magic); /* big-endian */
267 for (mp = exectab; mp->magic; mp++) {
268 if (nb < mp->hsize)
269 continue;
270
271 /*
272 * The.exec.magic number has morphed into something
273 * with fields (the straw was DYN_MAGIC) so now
274 * a flag is needed in Fhdr to distinguish _MAGIC()
275 * magic numbers from foreign magic numbers.
276 *
277 * This code is creaking a bit and if it has to
278 * be modified/extended much more it's probably
279 * time to step back and redo it all.
280 */
281 if(mp->_magic){
282 if(mp->magic != (magic & ~DYN_MAGIC))
283 continue;
284
285 if(mp->magic == V_MAGIC)
286 mp = couldbe4k(mp);
287
288 if ((magic & DYN_MAGIC) && mp->dlmname != nil)
289 fp->name = mp->dlmname;
290 else
291 fp->name = mp->name;
292 }
293 else{
294 if(mp->magic != magic)
295 continue;
296 fp->name = mp->name;
297 }
298 fp->type = mp->type;
299 fp->hdrsz = mp->hsize; /* will be zero on bootables */
300 fp->_magic = mp->_magic;
301 fp->magic = magic;
302
303 mach = mp->mach;
304 if(mp->swal != nil)
305 hswal(&d, sizeof(d.e)/sizeof(ulong), mp->swal);
306 ret = mp->hparse(fd, fp, &d);
307 seek(fd, mp->hsize, 0); /* seek to end of header */
308 break;
309 }
310 if(mp->magic == 0)
311 werrstr("unknown header type");
312 return ret;
313 }
314
315 /*
316 * Convert header to canonical form
317 */
318 static void
hswal(void * v,int n,ulong (* swap)(ulong))319 hswal(void *v, int n, ulong (*swap)(ulong))
320 {
321 ulong *ulp;
322
323 for(ulp = v; n--; ulp++)
324 *ulp = (*swap)(*ulp);
325 }
326
327 /*
328 * Crack a normal a.out-type header
329 */
330 static int
adotout(int fd,Fhdr * fp,ExecHdr * hp)331 adotout(int fd, Fhdr *fp, ExecHdr *hp)
332 {
333 long pgsize;
334
335 USED(fd);
336 pgsize = mach->pgsize;
337 settext(fp, hp->e.exec.entry, pgsize+sizeof(Exec),
338 hp->e.exec.text, sizeof(Exec));
339 setdata(fp, _round(pgsize+fp->txtsz+sizeof(Exec), pgsize),
340 hp->e.exec.data, fp->txtsz+sizeof(Exec), hp->e.exec.bss);
341 setsym(fp, hp->e.exec.syms, hp->e.exec.spsz, hp->e.exec.pcsz, fp->datoff+fp->datsz);
342 return 1;
343 }
344
345 static void
commonboot(Fhdr * fp)346 commonboot(Fhdr *fp)
347 {
348 if (!(fp->entry & mach->ktmask))
349 return;
350
351 switch(fp->type) { /* boot image */
352 case F68020:
353 fp->type = F68020B;
354 fp->name = "68020 plan 9 boot image";
355 break;
356 case FI386:
357 fp->type = FI386B;
358 fp->txtaddr = (u32int)fp->entry;
359 fp->name = "386 plan 9 boot image";
360 fp->dataddr = _round(fp->txtaddr+fp->txtsz, mach->pgsize);
361 break;
362 case FARM:
363 fp->type = FARMB;
364 fp->txtaddr = (u32int)fp->entry;
365 fp->name = "ARM plan 9 boot image";
366 fp->dataddr = _round(fp->txtaddr+fp->txtsz, mach->pgsize);
367 return;
368 case FPOWER:
369 fp->type = FPOWERB;
370 fp->txtaddr = (u32int)fp->entry;
371 fp->name = "power plan 9 boot image";
372 fp->dataddr = fp->txtaddr+fp->txtsz;
373 break;
374 case FAMD64:
375 fp->type = FAMD64B;
376 fp->txtaddr = fp->entry;
377 fp->name = "amd64 plan 9 boot image";
378 fp->dataddr = _round(fp->txtaddr+fp->txtsz, mach->pgsize);
379 break;
380 case FRISCV:
381 fp->type = FRISCVB;
382 fp->txtaddr = (u32int)fp->entry;
383 fp->name = "riscv plan 9 boot image";
384 fp->dataddr = _round(fp->txtaddr+fp->txtsz, mach->pgsize);
385 break;
386 default:
387 return;
388 }
389 fp->hdrsz = 0; /* header stripped */
390 }
391
392 /*
393 * _MAGIC() style headers and
394 * alpha plan9-style bootable images for axp "headerless" boot
395 *
396 */
397 static int
common(int fd,Fhdr * fp,ExecHdr * hp)398 common(int fd, Fhdr *fp, ExecHdr *hp)
399 {
400 adotout(fd, fp, hp);
401 if(hp->e.exec.magic & DYN_MAGIC) {
402 fp->txtaddr = 0;
403 fp->dataddr = fp->txtsz;
404 return 1;
405 }
406 commonboot(fp);
407 return 1;
408 }
409
410 static int
commonllp64(int fd,Fhdr * fp,ExecHdr * hp)411 commonllp64(int fd, Fhdr *fp, ExecHdr *hp)
412 {
413 long pgsize;
414 uvlong entry;
415
416 USED(fd);
417 hswal(&hp->e, sizeof(Exec)/sizeof(long), beswal);
418 if(!(hp->e.exec.magic & HDR_MAGIC))
419 return 0;
420
421 /*
422 * There can be more.exec.magic here if the
423 * header ever needs more expansion.
424 * For now just catch use of any of the
425 * unused bits.
426 */
427 if((hp->e.exec.magic & ~DYN_MAGIC)>>16)
428 return 0;
429 entry = beswav(hp->e.exechdr64.hdr[0]);
430
431 pgsize = mach->pgsize;
432 settext(fp, entry, pgsize+fp->hdrsz, hp->e.exec.text, fp->hdrsz);
433 setdata(fp, _round(pgsize+fp->txtsz+fp->hdrsz, pgsize),
434 hp->e.exec.data, fp->txtsz+fp->hdrsz, hp->e.exec.bss);
435 setsym(fp, hp->e.exec.syms, hp->e.exec.spsz, hp->e.exec.pcsz, fp->datoff+fp->datsz);
436
437 if(hp->e.exec.magic & DYN_MAGIC) {
438 fp->txtaddr = 0;
439 fp->dataddr = fp->txtsz;
440 return 1;
441 }
442 commonboot(fp);
443 return 1;
444 }
445
446 /*
447 * mips bootable image.
448 */
449 static int
mipsboot(int fd,Fhdr * fp,ExecHdr * hp)450 mipsboot(int fd, Fhdr *fp, ExecHdr *hp)
451 {
452 USED(fd);
453 fp->type = FMIPSB;
454 switch(hp->e.mips32.amagic) {
455 default:
456 case 0407: /* some kind of mips */
457 settext(fp, (u32int)hp->e.mips32.mentry, (u32int)hp->e.mips32.text_start,
458 hp->e.mips32.tsize, sizeof(struct mipsexec)+4);
459 setdata(fp, (u32int)hp->e.mips32.data_start, hp->e.mips32.dsize,
460 fp->txtoff+hp->e.mips32.tsize, hp->e.mips32.bsize);
461 break;
462 case 0413: /* some kind of mips */
463 settext(fp, (u32int)hp->e.mips32.mentry, (u32int)hp->e.mips32.text_start,
464 hp->e.mips32.tsize, 0);
465 setdata(fp, (u32int)hp->e.mips32.data_start, hp->e.mips32.dsize,
466 hp->e.mips32.tsize, hp->e.mips32.bsize);
467 break;
468 }
469 setsym(fp, hp->e.mips32.nsyms, 0, hp->e.mips32.pcsize, hp->e.mips32.symptr);
470 fp->hdrsz = 0; /* header stripped */
471 return 1;
472 }
473
474 /*
475 * mips4k bootable image.
476 */
477 static int
mips4kboot(int fd,Fhdr * fp,ExecHdr * hp)478 mips4kboot(int fd, Fhdr *fp, ExecHdr *hp)
479 {
480 USED(fd);
481 fp->type = FMIPSB;
482 switch(hp->e.mips4k.h.amagic) {
483 default:
484 case 0407: /* some kind of mips */
485 settext(fp, (u32int)hp->e.mips4k.h.mentry, (u32int)hp->e.mips4k.h.text_start,
486 hp->e.mips4k.h.tsize, sizeof(struct mips4kexec));
487 setdata(fp, (u32int)hp->e.mips4k.h.data_start, hp->e.mips4k.h.dsize,
488 fp->txtoff+hp->e.mips4k.h.tsize, hp->e.mips4k.h.bsize);
489 break;
490 case 0413: /* some kind of mips */
491 settext(fp, (u32int)hp->e.mips4k.h.mentry, (u32int)hp->e.mips4k.h.text_start,
492 hp->e.mips4k.h.tsize, 0);
493 setdata(fp, (u32int)hp->e.mips4k.h.data_start, hp->e.mips4k.h.dsize,
494 hp->e.mips4k.h.tsize, hp->e.mips4k.h.bsize);
495 break;
496 }
497 setsym(fp, hp->e.mips4k.h.nsyms, 0, hp->e.mips4k.h.pcsize, hp->e.mips4k.h.symptr);
498 fp->hdrsz = 0; /* header stripped */
499 return 1;
500 }
501
502 /*
503 * sparc bootable image
504 */
505 static int
sparcboot(int fd,Fhdr * fp,ExecHdr * hp)506 sparcboot(int fd, Fhdr *fp, ExecHdr *hp)
507 {
508 USED(fd);
509 fp->type = FSPARCB;
510 settext(fp, hp->e.sparc.sentry, hp->e.sparc.sentry, hp->e.sparc.stext,
511 sizeof(struct sparcexec));
512 setdata(fp, hp->e.sparc.sentry+hp->e.sparc.stext, hp->e.sparc.sdata,
513 fp->txtoff+hp->e.sparc.stext, hp->e.sparc.sbss);
514 setsym(fp, hp->e.sparc.ssyms, 0, hp->e.sparc.sdrsize, fp->datoff+hp->e.sparc.sdata);
515 fp->hdrsz = 0; /* header stripped */
516 return 1;
517 }
518
519 /*
520 * next bootable image
521 */
522 static int
nextboot(int fd,Fhdr * fp,ExecHdr * hp)523 nextboot(int fd, Fhdr *fp, ExecHdr *hp)
524 {
525 USED(fd);
526 fp->type = FNEXTB;
527 settext(fp, hp->e.next.textc.vmaddr, hp->e.next.textc.vmaddr,
528 hp->e.next.texts.size, hp->e.next.texts.offset);
529 setdata(fp, hp->e.next.datac.vmaddr, hp->e.next.datas.size,
530 hp->e.next.datas.offset, hp->e.next.bsss.size);
531 setsym(fp, hp->e.next.symc.nsyms, hp->e.next.symc.spoff, hp->e.next.symc.pcoff,
532 hp->e.next.symc.symoff);
533 fp->hdrsz = 0; /* header stripped */
534 return 1;
535 }
536
537 /*
538 * Elf32 binaries.
539 */
540 static int
elfdotout(int fd,Fhdr * fp,ExecHdr * hp)541 elfdotout(int fd, Fhdr *fp, ExecHdr *hp)
542 {
543
544 ulong (*swal)(ulong);
545 ushort (*swab)(ushort);
546 Ehdr *ep;
547 Phdr *ph;
548 int i, it, id, is, phsz;
549
550 /* bitswap the header according to the DATA format */
551 ep = &hp->e.elfhdr32;
552 if(ep->ident[CLASS] != ELFCLASS32) {
553 werrstr("bad ELF class - not 32 bit");
554 return 0;
555 }
556 if(ep->ident[DATA] == ELFDATA2LSB) {
557 swab = leswab;
558 swal = leswal;
559 } else if(ep->ident[DATA] == ELFDATA2MSB) {
560 swab = beswab;
561 swal = beswal;
562 } else {
563 werrstr("bad ELF encoding - not big or little endian");
564 return 0;
565 }
566
567 ep->type = swab(ep->type);
568 ep->machine = swab(ep->machine);
569 ep->version = swal(ep->version);
570 ep->elfentry = swal(ep->elfentry);
571 ep->phoff = swal(ep->phoff);
572 ep->shoff = swal(ep->shoff);
573 ep->flags = swal(ep->flags);
574 ep->ehsize = swab(ep->ehsize);
575 ep->phentsize = swab(ep->phentsize);
576 ep->phnum = swab(ep->phnum);
577 ep->shentsize = swab(ep->shentsize);
578 ep->shnum = swab(ep->shnum);
579 ep->shstrndx = swab(ep->shstrndx);
580 if(ep->type != EXEC || ep->version != CURRENT)
581 return 0;
582
583 /* we could definitely support a lot more machines here */
584 fp->magic = ELF_MAG;
585 fp->hdrsz = (ep->ehsize+ep->phnum*ep->phentsize+16)&~15;
586 switch(ep->machine) {
587 case I386:
588 mach = &mi386;
589 fp->type = FI386;
590 break;
591 case MIPS:
592 mach = &mmips;
593 fp->type = FMIPS;
594 break;
595 case SPARC64:
596 return 0;
597 case POWER:
598 mach = &mpower;
599 fp->type = FPOWER;
600 break;
601 case AMD64:
602 mach = &mamd64;
603 fp->type = FAMD64;
604 break;
605 case ARM:
606 mach = &marm;
607 fp->type = FARM;
608 break;
609 case RISCV:
610 mach = &mriscv;
611 fp->type = FRISCV;
612 break;
613 default:
614 return 0;
615 }
616
617 if(ep->phentsize != sizeof(Phdr)) {
618 werrstr("bad ELF header size");
619 return 0;
620 }
621 phsz = sizeof(Phdr)*ep->phnum;
622 ph = malloc(phsz);
623 if(!ph)
624 return 0;
625 seek(fd, ep->phoff, 0);
626 if(read(fd, ph, phsz) < 0) {
627 free(ph);
628 return 0;
629 }
630 hswal(ph, phsz/sizeof(ulong), swal);
631
632 /* find text, data and symbols and install them */
633 it = id = is = -1;
634 for(i = 0; i < ep->phnum; i++) {
635 if(ph[i].type == LOAD
636 && (ph[i].flags & (R|X)) == (R|X) && it == -1)
637 it = i;
638 else if(ph[i].type == LOAD
639 && (ph[i].flags & (R|W)) == (R|W) && id == -1)
640 id = i;
641 else if(ph[i].type == NOPTYPE && is == -1)
642 is = i;
643 }
644 if(it == -1 || id == -1) {
645 /*
646 * The SPARC64 boot image is something of an ELF hack.
647 * Text+Data+BSS are represented by ph[0]. Symbols
648 * are represented by ph[1]:
649 *
650 * filesz, memsz, vaddr, paddr, off
651 * ph[0] : txtsz+datsz, txtsz+datsz+bsssz, txtaddr-KZERO, datasize, txtoff
652 * ph[1] : symsz, lcsz, 0, 0, symoff
653 */
654 if(ep->machine == SPARC64 && ep->phnum == 2) {
655 ulong txtaddr, txtsz, dataddr, bsssz;
656
657 txtaddr = ph[0].vaddr | 0x80000000;
658 txtsz = ph[0].filesz - ph[0].paddr;
659 dataddr = txtaddr + txtsz;
660 bsssz = ph[0].memsz - ph[0].filesz;
661 settext(fp, ep->elfentry | 0x80000000, txtaddr, txtsz, ph[0].offset);
662 setdata(fp, dataddr, ph[0].paddr, ph[0].offset + txtsz, bsssz);
663 setsym(fp, ph[1].filesz, 0, ph[1].memsz, ph[1].offset);
664 free(ph);
665 return 1;
666 }
667
668 werrstr("No TEXT or DATA sections");
669 free(ph);
670 return 0;
671 }
672
673 settext(fp, ep->elfentry, ph[it].vaddr, ph[it].memsz, ph[it].offset);
674 setdata(fp, ph[id].vaddr, ph[id].filesz, ph[id].offset, ph[id].memsz - ph[id].filesz);
675 if(is != -1)
676 setsym(fp, ph[is].filesz, 0, ph[is].memsz, ph[is].offset);
677 free(ph);
678 return 1;
679 }
680
681 /*
682 * (Free|Net)BSD ARM header.
683 */
684 static int
armdotout(int fd,Fhdr * fp,ExecHdr * hp)685 armdotout(int fd, Fhdr *fp, ExecHdr *hp)
686 {
687 uvlong kbase;
688
689 USED(fd);
690 settext(fp, hp->e.exec.entry, sizeof(Exec), hp->e.exec.text, sizeof(Exec));
691 setdata(fp, fp->txtsz, hp->e.exec.data, fp->txtsz, hp->e.exec.bss);
692 setsym(fp, hp->e.exec.syms, hp->e.exec.spsz, hp->e.exec.pcsz, fp->datoff+fp->datsz);
693
694 kbase = 0xF0000000;
695 if ((fp->entry & kbase) == kbase) { /* Boot image */
696 fp->txtaddr = kbase+sizeof(Exec);
697 fp->name = "ARM *BSD boot image";
698 fp->hdrsz = 0; /* header stripped */
699 fp->dataddr = kbase+fp->txtsz;
700 }
701 return 1;
702 }
703
704 static void
settext(Fhdr * fp,uvlong e,uvlong a,long s,vlong off)705 settext(Fhdr *fp, uvlong e, uvlong a, long s, vlong off)
706 {
707 fp->txtaddr = a;
708 fp->entry = e;
709 fp->txtsz = s;
710 fp->txtoff = off;
711 }
712
713 static void
setdata(Fhdr * fp,uvlong a,long s,vlong off,long bss)714 setdata(Fhdr *fp, uvlong a, long s, vlong off, long bss)
715 {
716 fp->dataddr = a;
717 fp->datsz = s;
718 fp->datoff = off;
719 fp->bsssz = bss;
720 }
721
722 static void
setsym(Fhdr * fp,long symsz,long sppcsz,long lnpcsz,vlong symoff)723 setsym(Fhdr *fp, long symsz, long sppcsz, long lnpcsz, vlong symoff)
724 {
725 fp->symsz = symsz;
726 fp->symoff = symoff;
727 fp->sppcsz = sppcsz;
728 fp->sppcoff = fp->symoff+fp->symsz;
729 fp->lnpcsz = lnpcsz;
730 fp->lnpcoff = fp->sppcoff+fp->sppcsz;
731 }
732
733
734 static uvlong
_round(uvlong a,ulong b)735 _round(uvlong a, ulong b)
736 {
737 uvlong w;
738
739 w = (a/b)*b;
740 if (a!=w)
741 w += b;
742 return(w);
743 }
744