elf2bb.c revision 1.2
1 /* $NetBSD: elf2bb.c,v 1.2 2002/01/26 13:21:11 aymeric Exp $ */ 2 3 /*- 4 * Copyright (c) 1996 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Ignatios Souvatzis. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <sys/types.h> 40 41 #include <err.h> 42 #include <fcntl.h> 43 #include <stdio.h> 44 #include <stdlib.h> 45 #include <string.h> 46 #include <unistd.h> 47 48 #include <sys/mman.h> /* of the machine we're running on */ 49 #include <machine/endian.h> /* of the machine we're running on */ 50 51 #include <elf.h> /* TARGET */ 52 #ifndef R_68K_32 /* XXX host not m68k XXX */ 53 #define R_68K_32 1 54 #define R_68K_PC32 4 55 #define R_68K_PC16 5 56 #endif 57 58 #include "elf2bb.h" 59 #include "chksum.h" 60 61 void usage(void); 62 int intcmp(const void *, const void *); 63 int main(int argc, char *argv[]); 64 65 #ifdef DEBUG 66 #define dprintf(x) if (debug) printf x 67 #else 68 #define dprintf(x) 69 #endif 70 int debug; 71 72 #define BBSIZE 8192 73 74 char *progname; 75 int bbsize = BBSIZE; 76 u_int8_t *buffer; 77 u_int32_t *relbuf; 78 /* can't have more relocs than that*/ 79 80 int 81 intcmp(const void *i, const void *j) 82 { 83 int r; 84 85 r = (*(u_int32_t *)i) < (*(u_int32_t *)j); 86 87 return 2*r-1; 88 } 89 90 int 91 main(int argc, char *argv[]) 92 { 93 int ifd, ofd; 94 u_int mid, flags, magic; 95 caddr_t image; 96 Elf32_Ehdr *eh; 97 Elf32_Shdr *sh; 98 char *shstrtab; 99 Elf32_Sym *symtab; 100 char *strtab; 101 int eval(Elf32_Sym *, u_int32_t *); 102 u_int32_t *lptr; 103 int i, l, delta; 104 u_int8_t *rpo; 105 u_int32_t oldaddr, addrdiff; 106 u_int32_t tsz, dsz, bsz, trsz, drsz, entry, relver; 107 u_int32_t pcrelsz, r32sz; 108 int sumsize = 16; 109 int c; 110 u_int32_t *sect_offset; 111 112 113 progname = argv[0]; 114 115 /* insert getopt here, if needed */ 116 while ((c = getopt(argc, argv, "dFS:")) != -1) 117 switch(c) { 118 case 'F': 119 sumsize = 2; 120 break; 121 case 'S': 122 bbsize = (atoi(optarg) + 511) & ~511; 123 sumsize = bbsize / 512; 124 break; 125 case 'd': 126 debug = 1; 127 break; 128 default: 129 usage(); 130 } 131 argv += optind; 132 argc -= optind; 133 134 if (argc < 2) 135 usage(); 136 137 buffer = malloc(bbsize); 138 relbuf = (u_int32_t *)malloc(bbsize); 139 if (buffer == NULL || relbuf == NULL) 140 err(1, "Unable to allocate memory\n"); 141 142 ifd = open(argv[0], O_RDONLY, 0); 143 if (ifd < 0) 144 err(1, "Can't open %s", argv[0]); 145 146 image = mmap(0, 65536, PROT_READ, MAP_FILE|MAP_PRIVATE, ifd, 0); 147 if (image == 0) 148 err(1, "Can't mmap %s", argv[1]); 149 150 eh = (Elf32_Ehdr *)image; /* XXX endianness */ 151 152 dprintf(("%04x sections, offset %08x\n", htobe16(eh->e_shnum), htobe32(eh->e_shoff))); 153 if (htobe16(eh->e_type) != ET_REL) 154 errx(1, "%s isn't a relocatable file, type=%d\n", 155 argv[0], htobe16(eh->e_type)); 156 if (htobe16(eh->e_machine) != EM_68K) 157 errx(1, "%s isn't M68K, machine=%d\n", argv[0], 158 htobe16(eh->e_machine)); 159 160 tsz = dsz = bsz = trsz = pcrelsz = r32sz = 0; 161 sh = (Elf32_Shdr *)(image + htobe32(eh->e_shoff)); 162 shstrtab = (char *)(image + htobe32(sh[htobe16(eh->e_shstrndx)].sh_offset)); 163 symtab = NULL; /*XXX*/ 164 strtab = NULL; /*XXX*/ 165 dprintf((" name type flags addr offset size align\n")); 166 for (i = 0; i < htobe16(eh->e_shnum); ++i) { 167 u_int32_t sh_size; 168 169 dprintf( ("%2d: %08x %-16s %08x %08x %08x %08x %08x %08x\n", i, 170 htobe32(sh[i].sh_name), shstrtab + htobe32(sh[i].sh_name), 171 htobe32(sh[i].sh_type), 172 htobe32(sh[i].sh_flags), htobe32(sh[i].sh_addr), 173 htobe32(sh[i].sh_offset), htobe32(sh[i].sh_size), 174 htobe32(sh[i].sh_addralign))); 175 sh_size = (htobe32(sh[i].sh_size) + htobe32(sh[i].sh_addralign) - 1) & 176 -htobe32(sh[i].sh_addralign); 177 if (htobe32(sh[i].sh_type) == SHT_PROGBITS) { 178 if (htobe32(sh[i].sh_flags) & SHF_WRITE) 179 dsz += sh_size; 180 else 181 tsz += sh_size; 182 } else if (htobe32(sh[i].sh_type) == SHT_NOBITS && 183 htobe32(sh[i].sh_flags) == (SHF_ALLOC | SHF_WRITE)) { 184 bsz += sh_size;; 185 } else if (htobe32(sh[i].sh_type) == SHT_RELA) { 186 trsz += htobe32(sh[i].sh_size); 187 } 188 /* Check for SHT_REL? */ 189 else if (htobe32(sh[i].sh_type) == SHT_SYMTAB) { 190 symtab = (Elf32_Sym *)(image + htobe32(sh[i].sh_offset)); 191 } else if (strcmp(".strtab", shstrtab + htobe32(sh[i].sh_name)) == 0) { 192 strtab = image + htobe32(sh[i].sh_offset); 193 } 194 } 195 dprintf(("tsz = 0x%x, dsz = 0x%x, bsz = 0x%x, total 0x%x\n", 196 tsz, dsz, bsz, tsz + dsz + bsz)); 197 198 if (trsz == 0) 199 errx(1, "%s has no relocation records.\n", argv[0]); 200 201 dprintf(("%d relocs\n", trsz/12)); 202 203 /* 204 * We have one contiguous area allocated by the ROM to us. 205 */ 206 if (tsz+dsz+bsz > bbsize) 207 errx(1, "%s: resulting image too big\n", argv[0]); 208 209 memset(buffer, bbsize, 0); 210 211 /* Allocate and load loadable sections */ 212 sect_offset = (u_int32_t *)malloc(htobe16(eh->e_shnum) * sizeof(u_int32_t)); 213 for (i = 0, l = 0; i < htobe16(eh->e_shnum); ++i) { 214 if (htobe32(sh[i].sh_type) == SHT_PROGBITS || 215 htobe32(sh[i].sh_type) == SHT_NOBITS) { 216 dprintf(("vaddr 0x%04x size 0x%04x offset 0x%04x section %s\n", 217 l, htobe32(sh[i].sh_size), htobe32(sh[i].sh_offset), 218 shstrtab + htobe32(sh[i].sh_name))); 219 if (htobe32(sh[i].sh_type) == SHT_PROGBITS) 220 memcpy(buffer + l, image + htobe32(sh[i].sh_offset), 221 htobe32(sh[i].sh_size)); 222 sect_offset[i] = l; 223 l += (htobe32(sh[i].sh_size) + htobe32(sh[i].sh_addralign) - 1) & 224 -htobe32(sh[i].sh_addralign); 225 } 226 } 227 228 /* 229 * Hm. This tool REALLY should understand more than one 230 * relocator version. For now, check that the relocator at 231 * the image start does understand what we output. 232 */ 233 relver = htobe32(*(u_int32_t *)(buffer + 4)); 234 switch (relver) { 235 default: 236 errx(1, "%s: unrecognized relocator version %d\n", 237 argv[0], relver); 238 /*NOTREACHED*/ 239 240 case RELVER_RELATIVE_BYTES: 241 rpo = buffer + bbsize - 1; 242 delta = -1; 243 break; 244 245 case RELVER_RELATIVE_BYTES_FORWARD: 246 rpo = buffer + tsz + dsz; 247 delta = +1; 248 *(u_int16_t *)(buffer + 14) = htobe16(tsz + dsz); 249 break; 250 } 251 252 if (symtab == NULL) 253 errx(1, "No symbol table found\n"); 254 /* 255 * Link sections and generate relocation data 256 * Nasty: .text, .rodata, .data, .bss sections are not linked 257 * Symbol table values relative to start of sections. 258 * For each relocation entry: 259 * Symbol value needs to be calculated: value + section offset 260 * Image data adjusted to calculated value of symbol + addend 261 * Add relocation table entry for 32-bit relocatable values 262 * PC-relative entries will be absolute and don't need relocation 263 */ 264 for (i = 0; i < htobe16(eh->e_shnum); ++i) { 265 int n; 266 Elf32_Rela *ra; 267 u_int8_t *base; 268 269 if (htobe32(sh[i].sh_type) != SHT_RELA) 270 continue; 271 base = NULL; 272 if (strncmp(shstrtab + htobe32(sh[i].sh_name), ".rela", 5) != 0) 273 err(1, "bad relocation section name %s", shstrtab + 274 htobe32(sh[i].sh_name)); 275 for (n = 0; n < htobe16(eh->e_shnum); ++n) { 276 if (strcmp(shstrtab + htobe32(sh[i].sh_name) + 5, shstrtab + 277 htobe32(sh[n].sh_name)) != 0) 278 continue; 279 base = buffer + sect_offset[n]; 280 break; 281 } 282 if (base == NULL) 283 errx(1, "Can't find section for reloc %s\n", shstrtab + 284 htobe32(sh[i].sh_name)); 285 ra = (Elf32_Rela *)(image + htobe32(sh[i].sh_offset)); 286 for (n = 0; n < htobe32(sh[i].sh_size); n += sizeof(Elf32_Rela), ++ra) { 287 int value; 288 value = htobe32(ra->r_addend) + 289 eval(&symtab[ELF32_R_SYM(htobe32(ra->r_info))], sect_offset); 290 dprintf(("reloc %04x info %04x (type %d sym %d) add 0x%x val %x\n", 291 htobe32(ra->r_offset), htobe32(ra->r_info), 292 ELF32_R_TYPE(htobe32(ra->r_info)), 293 ELF32_R_SYM(htobe32(ra->r_info)), 294 htobe32(ra->r_addend), value)); 295 switch (ELF32_R_TYPE(htobe32(ra->r_info))) { 296 case R_68K_32: 297 *((u_int32_t *)(base + htobe32(ra->r_offset))) = 298 htobe32(value); 299 relbuf[r32sz++] = (base - buffer) + htobe32(ra->r_offset); 300 break; 301 case R_68K_PC32: 302 ++pcrelsz; 303 *((int32_t *)(base + htobe32(ra->r_offset))) = 304 htobe32(value - htobe32(ra->r_offset)); 305 break; 306 case R_68K_PC16: 307 ++pcrelsz; 308 *((int16_t *)(base + htobe32(ra->r_offset))) = 309 htobe16(value - htobe32(ra->r_offset)); 310 break; 311 default: 312 errx(1, "Relocation type %d not supported", 313 ELF32_R_TYPE(htobe32(ra->r_info))); 314 } 315 } 316 } 317 dprintf(("%d PC-relative relocations, %d 32-bit relocations\n", 318 pcrelsz, r32sz)); 319 printf("%d absolute reloc%s found, ", r32sz, r32sz==1?"":"s"); 320 321 i = r32sz; 322 if (i > 1) 323 heapsort(relbuf, r32sz, 4, intcmp); 324 325 oldaddr = 0; 326 327 for (--i; i>=0; --i) { 328 dprintf(("0x%04x: ", relbuf[i])); 329 lptr = (u_int32_t *)&buffer[relbuf[i]]; 330 addrdiff = relbuf[i] - oldaddr; 331 dprintf(("(0x%04x, 0x%04x): ", *lptr, addrdiff)); 332 if (addrdiff > 255) { 333 *rpo = 0; 334 if (delta > 0) { 335 ++rpo; 336 *rpo++ = (relbuf[i] >> 8) & 0xff; 337 *rpo++ = relbuf[i] & 0xff; 338 dprintf(("%02x%02x%02x\n", 339 rpo[-3], rpo[-2], rpo[-1])); 340 } else { 341 *--rpo = relbuf[i] & 0xff; 342 *--rpo = (relbuf[i] >> 8) & 0xff; 343 --rpo; 344 dprintf(("%02x%02x%02x\n", 345 rpo[0], rpo[1], rpo[2])); 346 } 347 } else { 348 *rpo = addrdiff; 349 dprintf(("%02x\n", *rpo)); 350 rpo += delta; 351 } 352 353 oldaddr = relbuf[i]; 354 355 if (delta < 0 ? rpo <= buffer+tsz+dsz 356 : rpo >= buffer + bbsize) 357 errx(1, "Relocs don't fit."); 358 } 359 *rpo = 0; rpo += delta; 360 *rpo = 0; rpo += delta; 361 *rpo = 0; rpo += delta; 362 363 printf("using %d bytes, %d bytes remaining.\n", delta > 0 ? 364 rpo-buffer-tsz-dsz : buffer+bbsize-rpo, delta > 0 ? 365 buffer + bbsize - rpo : rpo - buffer - tsz - dsz); 366 /* 367 * RELOCs must fit into the bss area. 368 */ 369 if (delta < 0 ? rpo <= buffer+tsz+dsz 370 : rpo >= buffer + bbsize) 371 errx(1, "Relocs don't fit."); 372 373 ((u_int32_t *)buffer)[1] = 0; 374 ((u_int32_t *)buffer)[1] = 375 htobe32((0xffffffff - chksum((u_int32_t *)buffer, sumsize * 512 / 4))); 376 377 ofd = open(argv[1], O_CREAT|O_WRONLY, 0644); 378 if (ofd < 0) 379 err(1, "Can't open %s", argv[1]); 380 381 if (write(ofd, buffer, bbsize) != bbsize) 382 err(1, "Writing output file"); 383 384 exit(0); 385 } 386 387 void 388 usage(void) 389 { 390 fprintf(stderr, "Usage: %s [-F] bootprog bootprog.bin\n", 391 progname); 392 exit(1); 393 /* NOTREACHED */ 394 } 395 396 int 397 eval(Elf32_Sym *s, u_int32_t *o) 398 { 399 int value; 400 401 value = htobe32(s->st_value); 402 if (htobe16(s->st_shndx) < 0xf000) 403 value += o[htobe16(s->st_shndx)]; 404 else 405 printf("eval: %x\n", htobe16(s->st_shndx)); 406 return value; 407 } 408
Indexes created Fri Oct 03 02:09:57 GMT 2025