1 /* $NetBSD: elf2ecoff.c,v 1.20 2002/04/25 18:16:49 tv Exp $ */ 2 3 /* 4 * Copyright (c) 1997 Jonathan Stone 5 * All rights reserved. 6 * Copyright (c) 1995 7 * Ted Lemon (hereinafter referred to as the author) 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. The name of the author may not be used to endorse or promote products 18 * derived from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 */ 32 33 /* elf2ecoff.c 34 35 This program converts an elf executable to an ECOFF executable. 36 No symbol table is retained. This is useful primarily in building 37 net-bootable kernels for machines (e.g., DECstation and Alpha) which 38 only support the ECOFF object file format. */ 39 40 #if HAVE_CONFIG_H 41 #include "config.h" 42 #endif 43 44 #include <sys/types.h> 45 #include <err.h> 46 #include <errno.h> 47 #include <fcntl.h> 48 #include <unistd.h> 49 #include <sys/exec_elf.h> 50 #include <stdio.h> 51 #include <sys/exec_ecoff.h> 52 #include <stdlib.h> 53 #include <string.h> 54 #include <limits.h> 55 56 #define ISLAST(p) (p->n_un.n_name == 0 || p->n_un.n_name[0] == 0) 57 58 struct sect { 59 unsigned long vaddr; 60 unsigned long len; 61 }; 62 63 struct elf_syms { 64 int nsymbols; 65 Elf32_Sym *elf_syms; 66 off_t stringsize; 67 char *stringtab; 68 }; 69 70 struct ecoff_syms { 71 int nsymbols; 72 struct ecoff_extsym *ecoff_syms; 73 off_t stringsize; 74 char *stringtab; 75 }; 76 77 int debug = 0; 78 79 int phcmp(Elf32_Phdr * h1, Elf32_Phdr * h2); 80 81 82 char *saveRead(int file, off_t offset, off_t len, char *name); 83 void safewrite(int outfile, void *buf, off_t len, const char *msg); 84 void copy(int, int, off_t, off_t); 85 void combine(struct sect * base, struct sect * new, int paddable); 86 void translate_syms(struct elf_syms *, struct ecoff_syms *); 87 void 88 elf_symbol_table_to_ecoff(int out, int in, 89 struct ecoff_exechdr * ep, 90 off_t symoff, off_t symsize, 91 off_t stroff, off_t strsize); 92 93 94 int 95 make_ecoff_section_hdrs(struct ecoff_exechdr * ep, 96 struct ecoff_scnhdr * esecs); 97 98 void 99 write_ecoff_symhdr(int outfile, struct ecoff_exechdr * ep, 100 struct ecoff_symhdr * symhdrp, 101 long nesyms, long extsymoff, long extstroff, 102 long strsize); 103 104 void pad16(int fd, int size, const char *msg); 105 void bswap32_region(u_int32_t* , int); 106 107 int *symTypeTable; 108 int needswap; 109 110 111 112 113 void 114 elf_read_syms(struct elf_syms * elfsymsp, int infile, 115 off_t symoff, off_t symsize, off_t stroff, off_t strsize); 116 117 118 int 119 main(int argc, char **argv, char **envp) 120 { 121 Elf32_Ehdr ex; 122 Elf32_Phdr *ph; 123 Elf32_Shdr *sh; 124 char *shstrtab; 125 int strtabix, symtabix; 126 int i, pad; 127 struct sect text, data, bss; /* a.out-compatible sections */ 128 struct sect rdata, sdata, sbss; /* ECOFF-only sections */ 129 130 struct ecoff_exechdr ep; 131 struct ecoff_scnhdr esecs[6]; 132 struct ecoff_symhdr symhdr; 133 134 int infile, outfile; 135 unsigned long cur_vma = ULONG_MAX; 136 int symflag = 0; 137 int nsecs = 0; 138 int mipsel; 139 140 141 text.len = data.len = bss.len = 0; 142 text.vaddr = data.vaddr = bss.vaddr = 0; 143 144 rdata.len = sdata.len = sbss.len = 0; 145 rdata.vaddr = sdata.vaddr = sbss.vaddr = 0; 146 147 /* Check args... */ 148 if (argc < 3 || argc > 4) { 149 usage: 150 fprintf(stderr, 151 "usage: elf2ecoff <elf executable> <ECOFF executable> [-s]\n"); 152 exit(1); 153 } 154 if (argc == 4) { 155 if (strcmp(argv[3], "-s")) 156 goto usage; 157 symflag = 1; 158 } 159 /* Try the input file... */ 160 if ((infile = open(argv[1], O_RDONLY)) < 0) { 161 fprintf(stderr, "Can't open %s for read: %s\n", 162 argv[1], strerror(errno)); 163 exit(1); 164 } 165 /* Read the header, which is at the beginning of the file... */ 166 i = read(infile, &ex, sizeof ex); 167 if (i != sizeof ex) { 168 fprintf(stderr, "ex: %s: %s.\n", 169 argv[1], i ? strerror(errno) : "End of file reached"); 170 exit(1); 171 } 172 if (ex.e_ident[EI_DATA] == ELFDATA2LSB) 173 mipsel = 1; 174 else if (ex.e_ident[EI_DATA] == ELFDATA2MSB) 175 mipsel = 0; 176 else { 177 fprintf(stderr, "invalid ELF byte order %d\n", 178 ex.e_ident[EI_DATA]); 179 exit(1); 180 } 181 #if BYTE_ORDER == BIG_ENDIAN 182 if (mipsel) 183 needswap = 1; 184 else 185 needswap = 0; 186 #elif BYTE_ORDER == LITTLE_ENDIAN 187 if (mipsel) 188 needswap = 0; 189 else 190 needswap = 1; 191 #else 192 #error "unknown endian" 193 #endif 194 195 if (needswap) { 196 ex.e_type = bswap16(ex.e_type); 197 ex.e_machine = bswap16(ex.e_machine); 198 ex.e_version = bswap32(ex.e_version); 199 ex.e_entry = bswap32(ex.e_entry); 200 ex.e_phoff = bswap32(ex.e_phoff); 201 ex.e_shoff = bswap32(ex.e_shoff); 202 ex.e_flags = bswap32(ex.e_flags); 203 ex.e_ehsize = bswap16(ex.e_ehsize); 204 ex.e_phentsize = bswap16(ex.e_phentsize); 205 ex.e_phnum = bswap16(ex.e_phnum); 206 ex.e_shentsize = bswap16(ex.e_shentsize); 207 ex.e_shnum = bswap16(ex.e_shnum); 208 ex.e_shstrndx = bswap16(ex.e_shstrndx); 209 } 210 211 /* Read the program headers... */ 212 ph = (Elf32_Phdr *) saveRead(infile, ex.e_phoff, 213 ex.e_phnum * sizeof(Elf32_Phdr), "ph"); 214 if (needswap) 215 bswap32_region((u_int32_t*)ph, sizeof(Elf32_Phdr) * ex.e_phnum); 216 /* Read the section headers... */ 217 sh = (Elf32_Shdr *) saveRead(infile, ex.e_shoff, 218 ex.e_shnum * sizeof(Elf32_Shdr), "sh"); 219 if (needswap) 220 bswap32_region((u_int32_t*)sh, sizeof(Elf32_Shdr) * ex.e_shnum); 221 222 /* Read in the section string table. */ 223 shstrtab = saveRead(infile, sh[ex.e_shstrndx].sh_offset, 224 sh[ex.e_shstrndx].sh_size, "shstrtab"); 225 226 227 /* Look for the symbol table and string table... Also map section 228 * indices to symbol types for a.out */ 229 symtabix = 0; 230 strtabix = 0; 231 for (i = 0; i < ex.e_shnum; i++) { 232 char *name = shstrtab + sh[i].sh_name; 233 if (!strcmp(name, ".symtab")) 234 symtabix = i; 235 else 236 if (!strcmp(name, ".strtab")) 237 strtabix = i; 238 239 } 240 241 /* Figure out if we can cram the program header into an ECOFF 242 * header... Basically, we can't handle anything but loadable 243 * segments, but we can ignore some kinds of segments. We can't 244 * handle holes in the address space. Segments may be out of order, 245 * so we sort them first. */ 246 247 qsort(ph, ex.e_phnum, sizeof(Elf32_Phdr), 248 (int (*) (const void *, const void *)) phcmp); 249 250 for (i = 0; i < ex.e_phnum; i++) { 251 /* Section types we can ignore... */ 252 if (ph[i].p_type == PT_NULL || ph[i].p_type == PT_NOTE || 253 ph[i].p_type == PT_PHDR || 254 ph[i].p_type == PT_MIPS_REGINFO) { 255 256 if (debug) { 257 fprintf(stderr, " skipping PH %d type %d flags 0x%x\n", 258 i, ph[i].p_type, ph[i].p_flags); 259 } 260 continue; 261 } 262 /* Section types we can't handle... */ 263 else 264 if (ph[i].p_type != PT_LOAD) { 265 fprintf(stderr, "Program header %d type %d can't be converted.\n", 266 i, ph[i].p_type); 267 exit(1); 268 } 269 /* Writable (data) segment? */ 270 if (ph[i].p_flags & PF_W) { 271 struct sect ndata, nbss; 272 273 ndata.vaddr = ph[i].p_vaddr; 274 ndata.len = ph[i].p_filesz; 275 nbss.vaddr = ph[i].p_vaddr + ph[i].p_filesz; 276 nbss.len = ph[i].p_memsz - ph[i].p_filesz; 277 278 if (debug) { 279 fprintf(stderr, 280 " combinining PH %d type %d flags 0x%x with data, ndata = %ld, nbss =%ld\n", i, ph[i].p_type, ph[i].p_flags, ndata.len, nbss.len); 281 } 282 combine(&data, &ndata, 0); 283 combine(&bss, &nbss, 1); 284 } else { 285 struct sect ntxt; 286 287 ntxt.vaddr = ph[i].p_vaddr; 288 ntxt.len = ph[i].p_filesz; 289 if (debug) { 290 291 fprintf(stderr, 292 " combinining PH %d type %d flags 0x%x with text, len = %ld\n", 293 i, ph[i].p_type, ph[i].p_flags, ntxt.len); 294 } 295 combine(&text, &ntxt, 0); 296 } 297 /* Remember the lowest segment start address. */ 298 if (ph[i].p_vaddr < cur_vma) 299 cur_vma = ph[i].p_vaddr; 300 } 301 302 /* Sections must be in order to be converted... */ 303 if (text.vaddr > data.vaddr || data.vaddr > bss.vaddr || 304 text.vaddr + text.len > data.vaddr || data.vaddr + data.len > bss.vaddr) { 305 fprintf(stderr, "Sections ordering prevents a.out conversion.\n"); 306 exit(1); 307 } 308 /* If there's a data section but no text section, then the loader 309 * combined everything into one section. That needs to be the text 310 * section, so just make the data section zero length following text. */ 311 if (data.len && !text.len) { 312 text = data; 313 data.vaddr = text.vaddr + text.len; 314 data.len = 0; 315 } 316 /* If there is a gap between text and data, we'll fill it when we copy 317 * the data, so update the length of the text segment as represented 318 * in a.out to reflect that, since a.out doesn't allow gaps in the 319 * program address space. */ 320 if (text.vaddr + text.len < data.vaddr) 321 text.len = data.vaddr - text.vaddr; 322 323 /* We now have enough information to cons up an a.out header... */ 324 ep.a.magic = ECOFF_OMAGIC; 325 ep.a.vstamp = 2 * 256 + 10; /* compatible with version 2.10 */ 326 ep.a.tsize = text.len; 327 ep.a.dsize = data.len; 328 ep.a.bsize = bss.len; 329 ep.a.entry = ex.e_entry; 330 ep.a.text_start = text.vaddr; 331 ep.a.data_start = data.vaddr; 332 ep.a.bss_start = bss.vaddr; 333 ep.a.gprmask = 0xf3fffffe; 334 memset(&ep.a.cprmask, 0, sizeof ep.a.cprmask); 335 ep.a.gp_value = 0; /* unused. */ 336 337 if (mipsel) 338 ep.f.f_magic = ECOFF_MAGIC_MIPSEL; 339 else 340 ep.f.f_magic = ECOFF_MAGIC_MIPSEB; 341 342 ep.f.f_nscns = 6; 343 ep.f.f_timdat = 0; /* bogus */ 344 ep.f.f_symptr = 0; 345 ep.f.f_nsyms = sizeof(struct ecoff_symhdr); 346 ep.f.f_opthdr = sizeof ep.a; 347 ep.f.f_flags = 0x100f; /* Stripped, not sharable. */ 348 349 memset(esecs, 0, sizeof(esecs)); 350 351 /* Make ECOFF section headers, with empty stubs for 352 * .rdata/.sdata/.sbss. */ 353 make_ecoff_section_hdrs(&ep, esecs); 354 355 nsecs = ep.f.f_nscns; 356 357 if (needswap) { 358 ep.f.f_magic = bswap16(ep.f.f_magic); 359 ep.f.f_nscns = bswap16(ep.f.f_nscns); 360 ep.f.f_timdat = bswap32(ep.f.f_timdat); 361 ep.f.f_symptr = bswap32(ep.f.f_symptr); 362 ep.f.f_nsyms = bswap32(ep.f.f_nsyms); 363 ep.f.f_opthdr = bswap16(ep.f.f_opthdr); 364 ep.f.f_flags = bswap16(ep.f.f_flags); 365 ep.a.magic = bswap16(ep.a.magic); 366 ep.a.vstamp = bswap16(ep.a.vstamp); 367 ep.a.tsize = bswap32(ep.a.tsize); 368 ep.a.dsize = bswap32(ep.a.dsize); 369 ep.a.bsize = bswap32(ep.a.bsize); 370 ep.a.entry = bswap32(ep.a.entry); 371 ep.a.text_start = bswap32(ep.a.text_start); 372 ep.a.data_start = bswap32(ep.a.data_start); 373 ep.a.bss_start = bswap32(ep.a.bss_start); 374 ep.a.gprmask = bswap32(ep.a.gprmask); 375 bswap32_region((u_int32_t*)ep.a.cprmask, sizeof(ep.a.cprmask)); 376 ep.a.gp_value = bswap32(ep.a.gp_value); 377 for (i = 0; i < sizeof(esecs) / sizeof(esecs[0]); i++) { 378 esecs[i].s_paddr = bswap32(esecs[i].s_paddr); 379 esecs[i].s_vaddr = bswap32(esecs[i].s_vaddr); 380 esecs[i].s_size = bswap32(esecs[i].s_size); 381 esecs[i].s_scnptr = bswap32(esecs[i].s_scnptr); 382 esecs[i].s_relptr = bswap32(esecs[i].s_relptr); 383 esecs[i].s_lnnoptr = bswap32(esecs[i].s_lnnoptr); 384 esecs[i].s_nreloc = bswap16(esecs[i].s_nreloc); 385 esecs[i].s_nlnno = bswap16(esecs[i].s_nlnno); 386 esecs[i].s_flags = bswap32(esecs[i].s_flags); 387 } 388 } 389 390 /* Make the output file... */ 391 if ((outfile = open(argv[2], O_WRONLY | O_CREAT, 0777)) < 0) { 392 fprintf(stderr, "Unable to create %s: %s\n", argv[2], strerror(errno)); 393 exit(1); 394 } 395 /* Truncate file... */ 396 if (ftruncate(outfile, 0)) { 397 warn("ftruncate %s", argv[2]); 398 } 399 /* Write the headers... */ 400 safewrite(outfile, &ep.f, sizeof(ep.f), "ep.f: write: %s\n"); 401 if (debug) 402 fprintf(stderr, "wrote %d byte file header.\n", sizeof(ep.f)); 403 404 safewrite(outfile, &ep.a, sizeof(ep.a), "ep.a: write: %s\n"); 405 if (debug) 406 fprintf(stderr, "wrote %d byte a.out header.\n", sizeof(ep.a)); 407 408 safewrite(outfile, &esecs, sizeof(esecs[0]) * nsecs, 409 "esecs: write: %s\n"); 410 if (debug) 411 fprintf(stderr, "wrote %d bytes of section headers.\n", 412 sizeof(esecs[0]) * nsecs); 413 414 415 pad = ((sizeof ep.f + sizeof ep.a + sizeof esecs) & 15); 416 if (pad) { 417 pad = 16 - pad; 418 pad16(outfile, pad, "ipad: write: %s\n"); 419 if (debug) 420 fprintf(stderr, "wrote %d byte pad.\n", pad); 421 } 422 /* Copy the loadable sections. Zero-fill any gaps less than 64k; 423 * complain about any zero-filling, and die if we're asked to 424 * zero-fill more than 64k. */ 425 for (i = 0; i < ex.e_phnum; i++) { 426 /* Unprocessable sections were handled above, so just verify 427 * that the section can be loaded before copying. */ 428 if (ph[i].p_type == PT_LOAD && ph[i].p_filesz) { 429 if (cur_vma != ph[i].p_vaddr) { 430 unsigned long gap = ph[i].p_vaddr - cur_vma; 431 char obuf[1024]; 432 if (gap > 65536) { 433 fprintf(stderr, "Intersegment gap (%ld bytes) too large.\n", 434 gap); 435 exit(1); 436 } 437 if (debug) 438 fprintf(stderr, "Warning: %ld byte intersegment gap.\n", gap); 439 memset(obuf, 0, sizeof obuf); 440 while (gap) { 441 int count = write(outfile, obuf, (gap > sizeof obuf 442 ? sizeof obuf : gap)); 443 if (count < 0) { 444 fprintf(stderr, "Error writing gap: %s\n", 445 strerror(errno)); 446 exit(1); 447 } 448 gap -= count; 449 } 450 } 451 if (debug) 452 fprintf(stderr, "writing %d bytes...\n", ph[i].p_filesz); 453 copy(outfile, infile, ph[i].p_offset, ph[i].p_filesz); 454 cur_vma = ph[i].p_vaddr + ph[i].p_filesz; 455 } 456 } 457 458 459 if (debug) 460 fprintf(stderr, "writing syms at offset 0x%lx\n", 461 (u_long) ep.f.f_symptr + sizeof(symhdr)); 462 463 /* Copy and translate the symbol table... */ 464 elf_symbol_table_to_ecoff(outfile, infile, &ep, 465 sh[symtabix].sh_offset, sh[symtabix].sh_size, 466 sh[strtabix].sh_offset, sh[strtabix].sh_size); 467 468 /* 469 * Write a page of padding for boot PROMS that read entire pages. 470 * Without this, they may attempt to read past the end of the 471 * data section, incur an error, and refuse to boot. 472 */ 473 { 474 char obuf[4096]; 475 memset(obuf, 0, sizeof obuf); 476 if (write(outfile, obuf, sizeof(obuf)) != sizeof(obuf)) { 477 fprintf(stderr, "Error writing PROM padding: %s\n", 478 strerror(errno)); 479 exit(1); 480 } 481 } 482 483 /* Looks like we won... */ 484 exit(0); 485 } 486 487 void 488 copy(out, in, offset, size) 489 int out, in; 490 off_t offset, size; 491 { 492 char ibuf[4096]; 493 int remaining, cur, count; 494 495 /* Go to the start of the ELF symbol table... */ 496 if (lseek(in, offset, SEEK_SET) < 0) { 497 perror("copy: lseek"); 498 exit(1); 499 } 500 remaining = size; 501 while (remaining) { 502 cur = remaining; 503 if (cur > sizeof ibuf) 504 cur = sizeof ibuf; 505 remaining -= cur; 506 if ((count = read(in, ibuf, cur)) != cur) { 507 fprintf(stderr, "copy: read: %s\n", 508 count ? strerror(errno) : "premature end of file"); 509 exit(1); 510 } 511 safewrite(out, ibuf, cur, "copy: write: %s\n"); 512 } 513 } 514 /* Combine two segments, which must be contiguous. If pad is true, it's 515 okay for there to be padding between. */ 516 void 517 combine(base, new, pad) 518 struct sect *base, *new; 519 int pad; 520 { 521 if (!base->len) 522 *base = *new; 523 else 524 if (new->len) { 525 if (base->vaddr + base->len != new->vaddr) { 526 if (pad) 527 base->len = new->vaddr - base->vaddr; 528 else { 529 fprintf(stderr, 530 "Non-contiguous data can't be converted.\n"); 531 exit(1); 532 } 533 } 534 base->len += new->len; 535 } 536 } 537 538 int 539 phcmp(h1, h2) 540 Elf32_Phdr *h1, *h2; 541 { 542 if (h1->p_vaddr > h2->p_vaddr) 543 return 1; 544 else 545 if (h1->p_vaddr < h2->p_vaddr) 546 return -1; 547 else 548 return 0; 549 } 550 551 char 552 * 553 saveRead(int file, off_t offset, off_t len, char *name) 554 { 555 char *tmp; 556 int count; 557 off_t off; 558 if ((off = lseek(file, offset, SEEK_SET)) < 0) { 559 fprintf(stderr, "%s: fseek: %s\n", name, strerror(errno)); 560 exit(1); 561 } 562 if (!(tmp = (char *) malloc(len))) { 563 fprintf(stderr, "%s: Can't allocate %ld bytes.\n", name, (long) len); 564 exit(1); 565 } 566 count = read(file, tmp, len); 567 if (count != len) { 568 fprintf(stderr, "%s: read: %s.\n", 569 name, count ? strerror(errno) : "End of file reached"); 570 exit(1); 571 } 572 return tmp; 573 } 574 575 void 576 safewrite(int outfile, void *buf, off_t len, const char *msg) 577 { 578 int written; 579 written = write(outfile, (char *) buf, len); 580 if (written != len) { 581 fprintf(stderr, msg, strerror(errno)); 582 exit(1); 583 } 584 } 585 586 587 /* 588 * Output only three ECOFF sections, corresponding to ELF psecs 589 * for text, data, and bss. 590 */ 591 int 592 make_ecoff_section_hdrs(ep, esecs) 593 struct ecoff_exechdr *ep; 594 struct ecoff_scnhdr *esecs; 595 596 { 597 ep->f.f_nscns = 6; /* XXX */ 598 599 strcpy(esecs[0].s_name, ".text"); 600 strcpy(esecs[1].s_name, ".data"); 601 strcpy(esecs[2].s_name, ".bss"); 602 603 esecs[0].s_paddr = esecs[0].s_vaddr = ep->a.text_start; 604 esecs[1].s_paddr = esecs[1].s_vaddr = ep->a.data_start; 605 esecs[2].s_paddr = esecs[2].s_vaddr = ep->a.bss_start; 606 esecs[0].s_size = ep->a.tsize; 607 esecs[1].s_size = ep->a.dsize; 608 esecs[2].s_size = ep->a.bsize; 609 610 esecs[0].s_scnptr = ECOFF_TXTOFF(ep); 611 esecs[1].s_scnptr = ECOFF_DATOFF(ep); 612 #if 0 613 esecs[2].s_scnptr = esecs[1].s_scnptr + 614 ECOFF_ROUND(esecs[1].s_size, ECOFF_SEGMENT_ALIGNMENT(ep)); 615 #endif 616 617 esecs[0].s_relptr = esecs[1].s_relptr = esecs[2].s_relptr = 0; 618 esecs[0].s_lnnoptr = esecs[1].s_lnnoptr = esecs[2].s_lnnoptr = 0; 619 esecs[0].s_nreloc = esecs[1].s_nreloc = esecs[2].s_nreloc = 0; 620 esecs[0].s_nlnno = esecs[1].s_nlnno = esecs[2].s_nlnno = 0; 621 622 esecs[1].s_flags = 0x100; /* ECOFF rdata */ 623 esecs[3].s_flags = 0x200; /* ECOFF sdata */ 624 esecs[4].s_flags = 0x400; /* ECOFF sbss */ 625 626 /* 627 * Set the symbol-table offset to point at the end of any 628 * sections we loaded above, so later code can use it to write 629 * symbol table info.. 630 */ 631 ep->f.f_symptr = esecs[1].s_scnptr + esecs[1].s_size; 632 return (ep->f.f_nscns); 633 } 634 635 636 /* 637 * Write the ECOFF symbol header. 638 * Guess at how big the symbol table will be. 639 * Mark all symbols as EXTERN (for now). 640 */ 641 void 642 write_ecoff_symhdr(out, ep, symhdrp, nesyms, extsymoff, extstroff, strsize) 643 int out; 644 struct ecoff_exechdr *ep; 645 struct ecoff_symhdr *symhdrp; 646 long nesyms, extsymoff, extstroff, strsize; 647 { 648 if (debug) 649 fprintf(stderr, "writing symhdr for %ld entries at offset 0x%lx\n", 650 nesyms, (u_long) ep->f.f_symptr); 651 652 ep->f.f_nsyms = sizeof(struct ecoff_symhdr); 653 654 memset(symhdrp, 0, sizeof(*symhdrp)); 655 symhdrp->esymMax = nesyms; 656 symhdrp->magic = 0x7009;/* XXX */ 657 symhdrp->cbExtOffset = extsymoff; 658 symhdrp->cbSsExtOffset = extstroff; 659 660 symhdrp->issExtMax = strsize; 661 if (debug) 662 fprintf(stderr, 663 "ECOFF symhdr: symhdr %x, strsize %lx, symsize %lx\n", 664 sizeof(*symhdrp), strsize, 665 (nesyms * sizeof(struct ecoff_extsym))); 666 667 if (needswap) { 668 bswap32_region((u_int32_t*)&symhdrp->ilineMax, 669 sizeof(*symhdrp) - sizeof(symhdrp->magic) - 670 sizeof(symhdrp->ilineMax)); 671 symhdrp->magic = bswap16(symhdrp->magic); 672 symhdrp->ilineMax = bswap16(symhdrp->ilineMax); 673 } 674 675 safewrite(out, symhdrp, sizeof(*symhdrp), 676 "writing symbol header: %s\n"); 677 } 678 679 680 void 681 elf_read_syms(elfsymsp, in, symoff, symsize, stroff, strsize) 682 struct elf_syms *elfsymsp; 683 int in; 684 off_t symoff, symsize; 685 off_t stroff, strsize; 686 { 687 register int nsyms; 688 int i; 689 nsyms = symsize / sizeof(Elf32_Sym); 690 691 /* Suck in the ELF symbol list... */ 692 elfsymsp->elf_syms = (Elf32_Sym *) 693 saveRead(in, symoff, nsyms * sizeof(Elf32_Sym), 694 "ELF symboltable"); 695 elfsymsp->nsymbols = nsyms; 696 if (needswap) { 697 for (i = 0; i < nsyms; i++) { 698 Elf32_Sym *s = &elfsymsp->elf_syms[i]; 699 s->st_name = bswap32(s->st_name); 700 s->st_value = bswap32(s->st_value); 701 s->st_size = bswap32(s->st_size); 702 s->st_shndx = bswap16(s->st_shndx); 703 } 704 } 705 706 /* Suck in the ELF string table... */ 707 elfsymsp->stringtab = (char *) 708 saveRead(in, stroff, strsize, "ELF string table"); 709 elfsymsp->stringsize = strsize; 710 } 711 712 713 /* 714 * 715 */ 716 void 717 elf_symbol_table_to_ecoff(out, in, ep, symoff, symsize, stroff, strsize) 718 int out, in; 719 struct ecoff_exechdr *ep; 720 off_t symoff, symsize; 721 off_t stroff, strsize; 722 { 723 724 struct elf_syms elfsymtab; 725 struct ecoff_syms ecoffsymtab; 726 register u_long ecoff_symhdr_off, symtaboff, stringtaboff; 727 register u_long nextoff, symtabsize, ecoff_strsize; 728 int nsyms, i; 729 struct ecoff_symhdr symhdr; 730 int padding; 731 732 /* Read in the ELF symbols. */ 733 elf_read_syms(&elfsymtab, in, symoff, symsize, stroff, strsize); 734 735 /* Approximate translation to ECOFF. */ 736 translate_syms(&elfsymtab, &ecoffsymtab); 737 nsyms = ecoffsymtab.nsymbols; 738 739 /* Compute output ECOFF symbol- and string-table offsets. */ 740 ecoff_symhdr_off = ep->f.f_symptr; 741 742 nextoff = ecoff_symhdr_off + sizeof(struct ecoff_symhdr); 743 stringtaboff = nextoff; 744 ecoff_strsize = ECOFF_ROUND(ecoffsymtab.stringsize, 745 (ECOFF_SEGMENT_ALIGNMENT(ep))); 746 747 748 nextoff = stringtaboff + ecoff_strsize; 749 symtaboff = nextoff; 750 symtabsize = nsyms * sizeof(struct ecoff_extsym); 751 symtabsize = ECOFF_ROUND(symtabsize, ECOFF_SEGMENT_ALIGNMENT(ep)); 752 753 /* Write out the symbol header ... */ 754 write_ecoff_symhdr(out, ep, &symhdr, nsyms, symtaboff, 755 stringtaboff, ecoffsymtab.stringsize); 756 757 /* Write out the string table... */ 758 padding = ecoff_strsize - ecoffsymtab.stringsize; 759 safewrite(out, ecoffsymtab.stringtab, ecoffsymtab.stringsize, 760 "string table: write: %s\n"); 761 if (padding) 762 pad16(out, padding, "string table: padding: %s\n"); 763 764 765 /* Write out the symbol table... */ 766 padding = symtabsize - (nsyms * sizeof(struct ecoff_extsym)); 767 768 for (i = 0; i < nsyms; i++) { 769 struct ecoff_extsym *es = &ecoffsymtab.ecoff_syms[i]; 770 es->es_flags = bswap16(es->es_flags); 771 es->es_ifd = bswap16(es->es_ifd); 772 bswap32_region(&es->es_strindex, 773 sizeof(*es) - sizeof(es->es_flags) - sizeof(es->es_ifd)); 774 } 775 safewrite(out, ecoffsymtab.ecoff_syms, 776 nsyms * sizeof(struct ecoff_extsym), 777 "symbol table: write: %s\n"); 778 if (padding) 779 pad16(out, padding, "symbols: padding: %s\n"); 780 } 781 782 783 784 /* 785 * In-memory translation of ELF symbosl to ECOFF. 786 */ 787 void 788 translate_syms(elfp, ecoffp) 789 struct elf_syms *elfp; 790 struct ecoff_syms *ecoffp; 791 { 792 793 int i; 794 char *oldstringbase; 795 char *newstrings, *nsp; 796 797 int nsyms, idx; 798 799 nsyms = elfp->nsymbols; 800 oldstringbase = elfp->stringtab; 801 802 /* Allocate space for corresponding ECOFF symbols. */ 803 memset(ecoffp, 0, sizeof(*ecoffp)); 804 805 ecoffp->nsymbols = 0; 806 ecoffp->ecoff_syms = malloc(sizeof(struct ecoff_extsym) * nsyms); 807 808 /* we are going to be no bigger than the ELF symbol table. */ 809 ecoffp->stringsize = elfp->stringsize; 810 ecoffp->stringtab = malloc(elfp->stringsize); 811 812 newstrings = (char *) ecoffp->stringtab; 813 nsp = (char *) ecoffp->stringtab; 814 if (!newstrings) { 815 fprintf(stderr, "No memory for new string table!\n"); 816 exit(1); 817 } 818 /* Copy and translate symbols... */ 819 idx = 0; 820 for (i = 0; i < nsyms; i++) { 821 int binding, type; 822 823 binding = ELF32_ST_BIND((elfp->elf_syms[i].st_info)); 824 type = ELF32_ST_TYPE((elfp->elf_syms[i].st_info)); 825 826 /* skip strange symbols */ 827 if (binding == 0) { 828 continue; 829 } 830 /* Copy the symbol into the new table */ 831 strcpy(nsp, oldstringbase + elfp->elf_syms[i].st_name); 832 ecoffp->ecoff_syms[idx].es_strindex = nsp - newstrings; 833 nsp += strlen(nsp) + 1; 834 835 /* translate symbol types to ECOFF XXX */ 836 ecoffp->ecoff_syms[idx].es_type = 1; 837 ecoffp->ecoff_syms[idx].es_class = 5; 838 839 /* Symbol values in executables should be compatible. */ 840 ecoffp->ecoff_syms[idx].es_value = elfp->elf_syms[i].st_value; 841 ecoffp->ecoff_syms[idx].es_symauxindex = 0xfffff; 842 843 idx++; 844 } 845 846 ecoffp->nsymbols = idx; 847 ecoffp->stringsize = nsp - newstrings; 848 } 849 /* 850 * pad to a 16-byte boundary 851 */ 852 void 853 pad16(int fd, int size, const char *msg) 854 { 855 safewrite(fd, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0", size, msg); 856 } 857 858 /* swap a 32bit region */ 859 void 860 bswap32_region(u_int32_t* p, int len) 861 { 862 int i; 863 864 for (i = 0; i < len / sizeof(u_int32_t); i++, p++) 865 *p = bswap32(*p); 866 } 867