1 /*- 2 * Copyright (c) 2010,2011 Kai Wang 3 * All rights reserved. 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 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/param.h> 28 #include <ctype.h> 29 #include <err.h> 30 #include <gelf.h> 31 #include <stdint.h> 32 #include <stdio.h> 33 #include <stdlib.h> 34 #include <string.h> 35 #include <unistd.h> 36 37 #include "elfcopy.h" 38 39 ELFTC_VCSID("$Id: ascii.c 3487 2016-08-24 18:12:08Z emaste $"); 40 41 static void append_data(struct section *s, const void *buf, size_t sz); 42 static char hex_digit(uint8_t n); 43 static int hex_value(int x); 44 static void finalize_data_section(struct section *s); 45 static int ishexdigit(int x); 46 static int ihex_read(const char *line, char *type, uint64_t *addr, 47 uint64_t *num, uint8_t *data, size_t *sz); 48 static void ihex_write(int ofd, int type, uint64_t addr, uint64_t num, 49 const void *buf, size_t sz); 50 static void ihex_write_00(int ofd, uint64_t addr, const void *buf, size_t sz); 51 static void ihex_write_01(int ofd); 52 static void ihex_write_04(int ofd, uint16_t addr); 53 static void ihex_write_05(int ofd, uint64_t e_entry); 54 static struct section *new_data_section(struct elfcopy *ecp, int sec_index, 55 uint64_t off, uint64_t addr); 56 static int read_num(const char *line, int *len, uint64_t *num, size_t sz, 57 int *checksum); 58 static int srec_read(const char *line, char *type, uint64_t *addr, 59 uint8_t *data, size_t *sz); 60 static void srec_write(int ofd, char type, uint64_t addr, const void *buf, 61 size_t sz); 62 static void srec_write_symtab(int ofd, const char *ofn, Elf *e, Elf_Scn *scn, 63 GElf_Shdr *sh); 64 static void srec_write_S0(int ofd, const char *ofn); 65 static void srec_write_Sd(int ofd, char dr, uint64_t addr, const void *buf, 66 size_t sz, size_t rlen); 67 static void srec_write_Se(int ofd, uint64_t e_entry, int forceS3); 68 static void write_num(char *line, int *len, uint64_t num, size_t sz, 69 int *checksum); 70 71 #define _LINE_BUFSZ 1024 72 #define _DATA_BUFSZ 256 73 74 /* 75 * Convert ELF object to S-Record. 76 */ 77 void 78 create_srec(struct elfcopy *ecp, int ifd, int ofd, const char *ofn) 79 { 80 Elf *e; 81 Elf_Scn *scn; 82 Elf_Data *d; 83 GElf_Ehdr eh; 84 GElf_Shdr sh; 85 uint64_t max_addr; 86 size_t rlen; 87 int elferr, addr_sz; 88 char dr; 89 90 if ((e = elf_begin(ifd, ELF_C_READ, NULL)) == NULL) 91 errx(EXIT_FAILURE, "elf_begin() failed: %s", 92 elf_errmsg(-1)); 93 94 /* Output a symbol table for `symbolsrec' target. */ 95 if (!strncmp(ecp->otgt, "symbolsrec", strlen("symbolsrec"))) { 96 scn = NULL; 97 while ((scn = elf_nextscn(e, scn)) != NULL) { 98 if (gelf_getshdr(scn, &sh) == NULL) { 99 warnx("gelf_getshdr failed: %s", 100 elf_errmsg(-1)); 101 (void) elf_errno(); 102 continue; 103 } 104 if (sh.sh_type != SHT_SYMTAB) 105 continue; 106 srec_write_symtab(ofd, ofn, e, scn, &sh); 107 break; 108 } 109 } 110 111 if (ecp->flags & SREC_FORCE_S3) 112 dr = '3'; 113 else { 114 /* 115 * Find maximum address size in the first iteration. 116 */ 117 max_addr = 0; 118 scn = NULL; 119 while ((scn = elf_nextscn(e, scn)) != NULL) { 120 if (gelf_getshdr(scn, &sh) == NULL) { 121 warnx("gelf_getshdr failed: %s", 122 elf_errmsg(-1)); 123 (void) elf_errno(); 124 continue; 125 } 126 if ((sh.sh_flags & SHF_ALLOC) == 0 || 127 sh.sh_type == SHT_NOBITS || 128 sh.sh_size == 0) 129 continue; 130 if ((uint64_t) sh.sh_addr > max_addr) 131 max_addr = sh.sh_addr; 132 } 133 elferr = elf_errno(); 134 if (elferr != 0) 135 warnx("elf_nextscn failed: %s", elf_errmsg(elferr)); 136 137 if (max_addr <= 0xFFFF) 138 dr = '1'; 139 else if (max_addr <= 0xFFFFFF) 140 dr = '2'; 141 else 142 dr = '3'; 143 } 144 145 if (ecp->flags & SREC_FORCE_LEN) { 146 addr_sz = dr - '0' + 1; 147 if (ecp->srec_len < 1) 148 rlen = 1; 149 else if (ecp->srec_len + addr_sz + 1 > 255) 150 rlen = 255 - (addr_sz + 1); 151 else 152 rlen = ecp->srec_len; 153 } else 154 rlen = 16; 155 156 /* Generate S0 record which contains the output filename. */ 157 srec_write_S0(ofd, ofn); 158 159 /* Generate S{1,2,3} data records for section data. */ 160 scn = NULL; 161 while ((scn = elf_nextscn(e, scn)) != NULL) { 162 if (gelf_getshdr(scn, &sh) == NULL) { 163 warnx("gelf_getshdr failed: %s", elf_errmsg(-1)); 164 (void) elf_errno(); 165 continue; 166 } 167 if ((sh.sh_flags & SHF_ALLOC) == 0 || 168 sh.sh_type == SHT_NOBITS || 169 sh.sh_size == 0) 170 continue; 171 if (sh.sh_addr > 0xFFFFFFFF) { 172 warnx("address space too big for S-Record file"); 173 continue; 174 } 175 (void) elf_errno(); 176 if ((d = elf_getdata(scn, NULL)) == NULL) { 177 elferr = elf_errno(); 178 if (elferr != 0) 179 warnx("elf_getdata failed: %s", elf_errmsg(-1)); 180 continue; 181 } 182 if (d->d_buf == NULL || d->d_size == 0) 183 continue; 184 srec_write_Sd(ofd, dr, sh.sh_addr, d->d_buf, d->d_size, rlen); 185 } 186 elferr = elf_errno(); 187 if (elferr != 0) 188 warnx("elf_nextscn failed: %s", elf_errmsg(elferr)); 189 190 /* Generate S{7,8,9} end of block record. */ 191 if (gelf_getehdr(e, &eh) == NULL) 192 errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", 193 elf_errmsg(-1)); 194 srec_write_Se(ofd, eh.e_entry, ecp->flags & SREC_FORCE_S3); 195 } 196 197 void 198 create_elf_from_srec(struct elfcopy *ecp, int ifd) 199 { 200 char line[_LINE_BUFSZ], name[_LINE_BUFSZ]; 201 uint8_t data[_DATA_BUFSZ]; 202 GElf_Ehdr oeh; 203 struct section *s, *shtab; 204 FILE *ifp; 205 uint64_t addr, entry, off, sec_addr; 206 uintmax_t st_value; 207 size_t sz; 208 int _ifd, first, sec_index, in_symtab, symtab_created; 209 char *rlt; 210 char type; 211 212 if ((_ifd = dup(ifd)) < 0) 213 err(EXIT_FAILURE, "dup failed"); 214 if ((ifp = fdopen(_ifd, "r")) == NULL) 215 err(EXIT_FAILURE, "fdopen failed"); 216 217 /* Create EHDR for output .o file. */ 218 if (gelf_newehdr(ecp->eout, ecp->oec) == NULL) 219 errx(EXIT_FAILURE, "gelf_newehdr failed: %s", 220 elf_errmsg(-1)); 221 if (gelf_getehdr(ecp->eout, &oeh) == NULL) 222 errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", 223 elf_errmsg(-1)); 224 225 /* Initialise e_ident fields. */ 226 oeh.e_ident[EI_CLASS] = ecp->oec; 227 oeh.e_ident[EI_DATA] = ecp->oed; 228 /* 229 * TODO: Set OSABI according to the OS platform where elfcopy(1) 230 * was build. (probably) 231 */ 232 oeh.e_ident[EI_OSABI] = ELFOSABI_NONE; 233 oeh.e_machine = ecp->oem; 234 oeh.e_type = ET_REL; 235 oeh.e_entry = 0; 236 237 ecp->flags |= RELOCATABLE; 238 239 /* Create .shstrtab section */ 240 init_shstrtab(ecp); 241 ecp->shstrtab->off = 0; 242 243 /* Data sections are inserted after EHDR. */ 244 off = gelf_fsize(ecp->eout, ELF_T_EHDR, 1, EV_CURRENT); 245 if (off == 0) 246 errx(EXIT_FAILURE, "gelf_fsize() failed: %s", elf_errmsg(-1)); 247 248 /* Create data sections. */ 249 s = NULL; 250 first = 1; 251 sec_index = 1; 252 sec_addr = entry = 0; 253 while (fgets(line, _LINE_BUFSZ, ifp) != NULL) { 254 sz = 0; 255 if (line[0] == '\r' || line[0] == '\n') 256 continue; 257 if (line[0] == '$' && line[1] == '$') { 258 ecp->flags |= SYMTAB_EXIST; 259 while ((rlt = fgets(line, _LINE_BUFSZ, ifp)) != NULL) { 260 if (line[0] == '$' && line[1] == '$') 261 break; 262 } 263 if (rlt == NULL) 264 break; 265 continue; 266 } 267 if (line[0] != 'S' || line[1] < '0' || line[1] > '9') { 268 warnx("Invalid srec record"); 269 continue; 270 } 271 if (srec_read(line, &type, &addr, data, &sz) < 0) { 272 warnx("Invalid srec record or mismatched checksum"); 273 continue; 274 } 275 switch (type) { 276 case '1': 277 case '2': 278 case '3': 279 if (sz == 0) 280 break; 281 if (first || sec_addr != addr) { 282 if (s != NULL) 283 finalize_data_section(s); 284 s = new_data_section(ecp, sec_index, off, 285 addr); 286 if (s == NULL) { 287 warnx("new_data_section failed"); 288 break; 289 } 290 sec_index++; 291 sec_addr = addr; 292 first = 0; 293 } 294 append_data(s, data, sz); 295 off += sz; 296 sec_addr += sz; 297 break; 298 case '7': 299 case '8': 300 case '9': 301 entry = addr; 302 break; 303 default: 304 break; 305 } 306 } 307 if (s != NULL) 308 finalize_data_section(s); 309 if (ferror(ifp)) 310 warn("fgets failed"); 311 312 /* Insert .shstrtab after data sections. */ 313 if ((ecp->shstrtab->os = elf_newscn(ecp->eout)) == NULL) 314 errx(EXIT_FAILURE, "elf_newscn failed: %s", 315 elf_errmsg(-1)); 316 insert_to_sec_list(ecp, ecp->shstrtab, 1); 317 318 /* Insert section header table here. */ 319 shtab = insert_shtab(ecp, 1); 320 321 /* 322 * Rescan and create symbol table if we found '$$' section in 323 * the first scan. 324 */ 325 symtab_created = 0; 326 in_symtab = 0; 327 if (ecp->flags & SYMTAB_EXIST) { 328 if (fseek(ifp, 0, SEEK_SET) < 0) { 329 warn("fseek failed"); 330 ecp->flags &= ~SYMTAB_EXIST; 331 goto done; 332 } 333 while (fgets(line, _LINE_BUFSZ, ifp) != NULL) { 334 if (in_symtab) { 335 if (line[0] == '$' && line[1] == '$') { 336 in_symtab = 0; 337 continue; 338 } 339 if (sscanf(line, "%s $%jx", name, 340 &st_value) != 2) { 341 warnx("Invalid symbolsrec record"); 342 continue; 343 } 344 if (!symtab_created) { 345 create_external_symtab(ecp); 346 symtab_created = 1; 347 } 348 add_to_symtab(ecp, name, st_value, 0, SHN_ABS, 349 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0, 1); 350 } 351 if (line[0] == '$' && line[1] == '$') { 352 in_symtab = 1; 353 continue; 354 } 355 } 356 } 357 if (ferror(ifp)) 358 warn("fgets failed"); 359 if (symtab_created) { 360 finalize_external_symtab(ecp); 361 create_symtab_data(ecp); 362 /* Count in .symtab and .strtab section headers. */ 363 shtab->sz += gelf_fsize(ecp->eout, ELF_T_SHDR, 2, EV_CURRENT); 364 } else 365 ecp->flags &= ~SYMTAB_EXIST; 366 367 done: 368 fclose(ifp); 369 370 /* Set entry point. */ 371 oeh.e_entry = entry; 372 373 /* 374 * Write the underlying ehdr. Note that it should be called 375 * before elf_setshstrndx() since it will overwrite e->e_shstrndx. 376 */ 377 if (gelf_update_ehdr(ecp->eout, &oeh) == 0) 378 errx(EXIT_FAILURE, "gelf_update_ehdr() failed: %s", 379 elf_errmsg(-1)); 380 381 /* Generate section name string table (.shstrtab). */ 382 set_shstrtab(ecp); 383 384 /* Update sh_name pointer for each section header entry. */ 385 update_shdr(ecp, 0); 386 387 /* Renew oeh to get the updated e_shstrndx. */ 388 if (gelf_getehdr(ecp->eout, &oeh) == NULL) 389 errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", 390 elf_errmsg(-1)); 391 392 /* Resync section offsets. */ 393 resync_sections(ecp); 394 395 /* Store SHDR offset in EHDR. */ 396 oeh.e_shoff = shtab->off; 397 398 /* Update ehdr since we modified e_shoff. */ 399 if (gelf_update_ehdr(ecp->eout, &oeh) == 0) 400 errx(EXIT_FAILURE, "gelf_update_ehdr() failed: %s", 401 elf_errmsg(-1)); 402 403 /* Write out the output elf object. */ 404 if (elf_update(ecp->eout, ELF_C_WRITE) < 0) 405 errx(EXIT_FAILURE, "elf_update() failed: %s", 406 elf_errmsg(-1)); 407 408 /* Release allocated resource. */ 409 free_elf(ecp); 410 } 411 412 void 413 create_ihex(int ifd, int ofd) 414 { 415 Elf *e; 416 Elf_Scn *scn; 417 Elf_Data *d; 418 GElf_Ehdr eh; 419 GElf_Shdr sh; 420 int elferr; 421 uint16_t addr_hi, old_addr_hi; 422 423 if ((e = elf_begin(ifd, ELF_C_READ, NULL)) == NULL) 424 errx(EXIT_FAILURE, "elf_begin() failed: %s", 425 elf_errmsg(-1)); 426 427 old_addr_hi = 0; 428 scn = NULL; 429 while ((scn = elf_nextscn(e, scn)) != NULL) { 430 if (gelf_getshdr(scn, &sh) == NULL) { 431 warnx("gelf_getshdr failed: %s", elf_errmsg(-1)); 432 (void) elf_errno(); 433 continue; 434 } 435 if ((sh.sh_flags & SHF_ALLOC) == 0 || 436 sh.sh_type == SHT_NOBITS || 437 sh.sh_size == 0) 438 continue; 439 if (sh.sh_addr > 0xFFFFFFFF) { 440 warnx("address space too big for Intel Hex file"); 441 continue; 442 } 443 (void) elf_errno(); 444 if ((d = elf_getdata(scn, NULL)) == NULL) { 445 elferr = elf_errno(); 446 if (elferr != 0) 447 warnx("elf_getdata failed: %s", elf_errmsg(-1)); 448 continue; 449 } 450 if (d->d_buf == NULL || d->d_size == 0) 451 continue; 452 addr_hi = (sh.sh_addr >> 16) & 0xFFFF; 453 if (addr_hi > 0 && addr_hi != old_addr_hi) { 454 /* Write 04 record if addr_hi is new. */ 455 old_addr_hi = addr_hi; 456 ihex_write_04(ofd, addr_hi); 457 } 458 ihex_write_00(ofd, sh.sh_addr, d->d_buf, d->d_size); 459 } 460 elferr = elf_errno(); 461 if (elferr != 0) 462 warnx("elf_nextscn failed: %s", elf_errmsg(elferr)); 463 464 if (gelf_getehdr(e, &eh) == NULL) 465 errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", 466 elf_errmsg(-1)); 467 ihex_write_05(ofd, eh.e_entry); 468 ihex_write_01(ofd); 469 } 470 471 void 472 create_elf_from_ihex(struct elfcopy *ecp, int ifd) 473 { 474 char line[_LINE_BUFSZ]; 475 uint8_t data[_DATA_BUFSZ]; 476 GElf_Ehdr oeh; 477 struct section *s, *shtab; 478 FILE *ifp; 479 uint64_t addr, addr_base, entry, num, off, rec_addr, sec_addr; 480 size_t sz; 481 int _ifd, first, sec_index; 482 char type; 483 484 if ((_ifd = dup(ifd)) < 0) 485 err(EXIT_FAILURE, "dup failed"); 486 if ((ifp = fdopen(_ifd, "r")) == NULL) 487 err(EXIT_FAILURE, "fdopen failed"); 488 489 /* Create EHDR for output .o file. */ 490 if (gelf_newehdr(ecp->eout, ecp->oec) == NULL) 491 errx(EXIT_FAILURE, "gelf_newehdr failed: %s", 492 elf_errmsg(-1)); 493 if (gelf_getehdr(ecp->eout, &oeh) == NULL) 494 errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", 495 elf_errmsg(-1)); 496 497 /* Initialise e_ident fields. */ 498 oeh.e_ident[EI_CLASS] = ecp->oec; 499 oeh.e_ident[EI_DATA] = ecp->oed; 500 /* 501 * TODO: Set OSABI according to the OS platform where elfcopy(1) 502 * was build. (probably) 503 */ 504 oeh.e_ident[EI_OSABI] = ELFOSABI_NONE; 505 oeh.e_machine = ecp->oem; 506 oeh.e_type = ET_REL; 507 oeh.e_entry = 0; 508 509 ecp->flags |= RELOCATABLE; 510 511 /* Create .shstrtab section */ 512 init_shstrtab(ecp); 513 ecp->shstrtab->off = 0; 514 515 /* Data sections are inserted after EHDR. */ 516 off = gelf_fsize(ecp->eout, ELF_T_EHDR, 1, EV_CURRENT); 517 if (off == 0) 518 errx(EXIT_FAILURE, "gelf_fsize() failed: %s", elf_errmsg(-1)); 519 520 /* Create data sections. */ 521 s = NULL; 522 first = 1; 523 sec_index = 1; 524 addr_base = rec_addr = sec_addr = entry = 0; 525 while (fgets(line, _LINE_BUFSZ, ifp) != NULL) { 526 if (line[0] == '\r' || line[0] == '\n') 527 continue; 528 if (line[0] != ':') { 529 warnx("Invalid ihex record"); 530 continue; 531 } 532 if (ihex_read(line, &type, &addr, &num, data, &sz) < 0) { 533 warnx("Invalid ihex record or mismatched checksum"); 534 continue; 535 } 536 switch (type) { 537 case '0': 538 /* Data record. */ 539 if (sz == 0) 540 break; 541 rec_addr = addr_base + addr; 542 if (first || sec_addr != rec_addr) { 543 if (s != NULL) 544 finalize_data_section(s); 545 s = new_data_section(ecp, sec_index, off, 546 rec_addr); 547 if (s == NULL) { 548 warnx("new_data_section failed"); 549 break; 550 } 551 sec_index++; 552 sec_addr = rec_addr; 553 first = 0; 554 } 555 append_data(s, data, sz); 556 off += sz; 557 sec_addr += sz; 558 break; 559 case '1': 560 /* End of file record. */ 561 goto done; 562 case '2': 563 /* Extended segment address record. */ 564 addr_base = addr << 4; 565 break; 566 case '3': 567 /* Start segment address record (CS:IP). Ignored. */ 568 break; 569 case '4': 570 /* Extended linear address record. */ 571 addr_base = num << 16; 572 break; 573 case '5': 574 /* Start linear address record. */ 575 entry = num; 576 break; 577 default: 578 break; 579 } 580 } 581 done: 582 if (s != NULL) 583 finalize_data_section(s); 584 if (ferror(ifp)) 585 warn("fgets failed"); 586 fclose(ifp); 587 588 /* Insert .shstrtab after data sections. */ 589 if ((ecp->shstrtab->os = elf_newscn(ecp->eout)) == NULL) 590 errx(EXIT_FAILURE, "elf_newscn failed: %s", 591 elf_errmsg(-1)); 592 insert_to_sec_list(ecp, ecp->shstrtab, 1); 593 594 /* Insert section header table here. */ 595 shtab = insert_shtab(ecp, 1); 596 597 /* Set entry point. */ 598 oeh.e_entry = entry; 599 600 /* 601 * Write the underlying ehdr. Note that it should be called 602 * before elf_setshstrndx() since it will overwrite e->e_shstrndx. 603 */ 604 if (gelf_update_ehdr(ecp->eout, &oeh) == 0) 605 errx(EXIT_FAILURE, "gelf_update_ehdr() failed: %s", 606 elf_errmsg(-1)); 607 608 /* Generate section name string table (.shstrtab). */ 609 set_shstrtab(ecp); 610 611 /* Update sh_name pointer for each section header entry. */ 612 update_shdr(ecp, 0); 613 614 /* Renew oeh to get the updated e_shstrndx. */ 615 if (gelf_getehdr(ecp->eout, &oeh) == NULL) 616 errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", 617 elf_errmsg(-1)); 618 619 /* Resync section offsets. */ 620 resync_sections(ecp); 621 622 /* Store SHDR offset in EHDR. */ 623 oeh.e_shoff = shtab->off; 624 625 /* Update ehdr since we modified e_shoff. */ 626 if (gelf_update_ehdr(ecp->eout, &oeh) == 0) 627 errx(EXIT_FAILURE, "gelf_update_ehdr() failed: %s", 628 elf_errmsg(-1)); 629 630 /* Write out the output elf object. */ 631 if (elf_update(ecp->eout, ELF_C_WRITE) < 0) 632 errx(EXIT_FAILURE, "elf_update() failed: %s", 633 elf_errmsg(-1)); 634 635 /* Release allocated resource. */ 636 free_elf(ecp); 637 } 638 639 #define _SEC_NAMESZ 64 640 #define _SEC_INIT_CAP 1024 641 642 static struct section * 643 new_data_section(struct elfcopy *ecp, int sec_index, uint64_t off, 644 uint64_t addr) 645 { 646 char *name; 647 648 if ((name = malloc(_SEC_NAMESZ)) == NULL) 649 errx(EXIT_FAILURE, "malloc failed"); 650 snprintf(name, _SEC_NAMESZ, ".sec%d", sec_index); 651 652 return (create_external_section(ecp, name, name, NULL, 0, off, 653 SHT_PROGBITS, ELF_T_BYTE, SHF_ALLOC | SHF_WRITE, 1, addr, 0)); 654 } 655 656 static void 657 finalize_data_section(struct section *s) 658 { 659 Elf_Data *od; 660 661 if ((od = elf_newdata(s->os)) == NULL) 662 errx(EXIT_FAILURE, "elf_newdata() failed: %s", 663 elf_errmsg(-1)); 664 od->d_align = s->align; 665 od->d_off = 0; 666 od->d_buf = s->buf; 667 od->d_size = s->sz; 668 od->d_version = EV_CURRENT; 669 } 670 671 static void 672 append_data(struct section *s, const void *buf, size_t sz) 673 { 674 uint8_t *p; 675 676 if (s->buf == NULL) { 677 s->sz = 0; 678 s->cap = _SEC_INIT_CAP; 679 if ((s->buf = malloc(s->cap)) == NULL) 680 err(EXIT_FAILURE, "malloc failed"); 681 } 682 683 while (sz + s->sz > s->cap) { 684 s->cap *= 2; 685 if ((s->buf = realloc(s->buf, s->cap)) == NULL) 686 err(EXIT_FAILURE, "realloc failed"); 687 } 688 689 p = s->buf; 690 memcpy(&p[s->sz], buf, sz); 691 s->sz += sz; 692 } 693 694 static int 695 srec_read(const char *line, char *type, uint64_t *addr, uint8_t *data, 696 size_t *sz) 697 { 698 uint64_t count, _checksum, num; 699 size_t addr_sz; 700 int checksum, i, len; 701 702 checksum = 0; 703 len = 2; 704 if (read_num(line, &len, &count, 1, &checksum) < 0) 705 return (-1); 706 *type = line[1]; 707 switch (*type) { 708 case '0': 709 case '1': 710 case '5': 711 case '9': 712 addr_sz = 2; 713 break; 714 case '2': 715 case '8': 716 addr_sz = 3; 717 break; 718 case '3': 719 case '7': 720 addr_sz = 4; 721 break; 722 default: 723 return (-1); 724 } 725 726 if (read_num(line, &len, addr, addr_sz, &checksum) < 0) 727 return (-1); 728 729 count -= addr_sz + 1; 730 if (*type >= '0' && *type <= '3') { 731 for (i = 0; (uint64_t) i < count; i++) { 732 if (read_num(line, &len, &num, 1, &checksum) < 0) 733 return -1; 734 data[i] = (uint8_t) num; 735 } 736 *sz = count; 737 } else 738 *sz = 0; 739 740 if (read_num(line, &len, &_checksum, 1, NULL) < 0) 741 return (-1); 742 743 if ((int) _checksum != (~checksum & 0xFF)) 744 return (-1); 745 746 return (0); 747 } 748 749 static void 750 srec_write_symtab(int ofd, const char *ofn, Elf *e, Elf_Scn *scn, GElf_Shdr *sh) 751 { 752 char line[_LINE_BUFSZ]; 753 GElf_Sym sym; 754 Elf_Data *d; 755 const char *name; 756 size_t sc; 757 int elferr, i; 758 759 #define _WRITE_LINE do { \ 760 if (write(ofd, line, strlen(line)) != (ssize_t) strlen(line)) \ 761 errx(EXIT_FAILURE, "write failed"); \ 762 } while (0) 763 764 765 (void) elf_errno(); 766 if ((d = elf_getdata(scn, NULL)) == NULL) { 767 elferr = elf_errno(); 768 if (elferr != 0) 769 warnx("elf_getdata failed: %s", 770 elf_errmsg(-1)); 771 return; 772 } 773 if (d->d_buf == NULL || d->d_size == 0) 774 return; 775 776 snprintf(line, sizeof(line), "$$ %s\r\n", ofn); 777 _WRITE_LINE; 778 sc = d->d_size / sh->sh_entsize; 779 for (i = 1; (size_t) i < sc; i++) { 780 if (gelf_getsym(d, i, &sym) != &sym) { 781 warnx("gelf_getsym failed: %s", elf_errmsg(-1)); 782 continue; 783 } 784 if (GELF_ST_TYPE(sym.st_info) == STT_SECTION || 785 GELF_ST_TYPE(sym.st_info) == STT_FILE) 786 continue; 787 if ((name = elf_strptr(e, sh->sh_link, sym.st_name)) == NULL) { 788 warnx("elf_strptr failed: %s", elf_errmsg(-1)); 789 continue; 790 } 791 snprintf(line, sizeof(line), " %s $%jx\r\n", name, 792 (uintmax_t) sym.st_value); 793 _WRITE_LINE; 794 } 795 snprintf(line, sizeof(line), "$$ \r\n"); 796 _WRITE_LINE; 797 798 #undef _WRITE_LINE 799 } 800 801 static void 802 srec_write_S0(int ofd, const char *ofn) 803 { 804 805 srec_write(ofd, '0', 0, ofn, strlen(ofn)); 806 } 807 808 static void 809 srec_write_Sd(int ofd, char dr, uint64_t addr, const void *buf, size_t sz, 810 size_t rlen) 811 { 812 const uint8_t *p, *pe; 813 814 p = buf; 815 pe = p + sz; 816 while (pe - p >= (int) rlen) { 817 srec_write(ofd, dr, addr, p, rlen); 818 addr += rlen; 819 p += rlen; 820 } 821 if (pe - p > 0) 822 srec_write(ofd, dr, addr, p, pe - p); 823 } 824 825 static void 826 srec_write_Se(int ofd, uint64_t e_entry, int forceS3) 827 { 828 char er; 829 830 if (e_entry > 0xFFFFFFFF) { 831 warnx("address space too big for S-Record file"); 832 return; 833 } 834 835 if (forceS3) 836 er = '7'; 837 else { 838 if (e_entry <= 0xFFFF) 839 er = '9'; 840 else if (e_entry <= 0xFFFFFF) 841 er = '8'; 842 else 843 er = '7'; 844 } 845 846 srec_write(ofd, er, e_entry, NULL, 0); 847 } 848 849 static void 850 srec_write(int ofd, char type, uint64_t addr, const void *buf, size_t sz) 851 { 852 char line[_LINE_BUFSZ]; 853 const uint8_t *p, *pe; 854 int len, addr_sz, checksum; 855 856 if (type == '0' || type == '1' || type == '5' || type == '9') 857 addr_sz = 2; 858 else if (type == '2' || type == '8') 859 addr_sz = 3; 860 else 861 addr_sz = 4; 862 863 checksum = 0; 864 line[0] = 'S'; 865 line[1] = type; 866 len = 2; 867 write_num(line, &len, addr_sz + sz + 1, 1, &checksum); 868 write_num(line, &len, addr, addr_sz, &checksum); 869 for (p = buf, pe = p + sz; p < pe; p++) 870 write_num(line, &len, *p, 1, &checksum); 871 write_num(line, &len, ~checksum & 0xFF, 1, NULL); 872 line[len++] = '\r'; 873 line[len++] = '\n'; 874 if (write(ofd, line, len) != (ssize_t) len) 875 err(EXIT_FAILURE, "write failed"); 876 } 877 878 static void 879 ihex_write_00(int ofd, uint64_t addr, const void *buf, size_t sz) 880 { 881 uint16_t addr_hi, old_addr_hi; 882 const uint8_t *p, *pe; 883 884 old_addr_hi = (addr >> 16) & 0xFFFF; 885 p = buf; 886 pe = p + sz; 887 while (pe - p >= 16) { 888 ihex_write(ofd, 0, addr, 0, p, 16); 889 addr += 16; 890 p += 16; 891 addr_hi = (addr >> 16) & 0xFFFF; 892 if (addr_hi != old_addr_hi) { 893 old_addr_hi = addr_hi; 894 ihex_write_04(ofd, addr_hi); 895 } 896 } 897 if (pe - p > 0) 898 ihex_write(ofd, 0, addr, 0, p, pe - p); 899 } 900 901 static int 902 ihex_read(const char *line, char *type, uint64_t *addr, uint64_t *num, 903 uint8_t *data, size_t *sz) 904 { 905 uint64_t count, _checksum; 906 int checksum, i, len; 907 908 *sz = 0; 909 checksum = 0; 910 len = 1; 911 if (read_num(line, &len, &count, 1, &checksum) < 0) 912 return (-1); 913 if (read_num(line, &len, addr, 2, &checksum) < 0) 914 return (-1); 915 if (line[len++] != '0') 916 return (-1); 917 *type = line[len++]; 918 checksum += *type - '0'; 919 switch (*type) { 920 case '0': 921 for (i = 0; (uint64_t) i < count; i++) { 922 if (read_num(line, &len, num, 1, &checksum) < 0) 923 return (-1); 924 data[i] = (uint8_t) *num; 925 } 926 *sz = count; 927 break; 928 case '1': 929 if (count != 0) 930 return (-1); 931 break; 932 case '2': 933 case '4': 934 if (count != 2) 935 return (-1); 936 if (read_num(line, &len, num, 2, &checksum) < 0) 937 return (-1); 938 break; 939 case '3': 940 case '5': 941 if (count != 4) 942 return (-1); 943 if (read_num(line, &len, num, 4, &checksum) < 0) 944 return (-1); 945 break; 946 default: 947 return (-1); 948 } 949 950 if (read_num(line, &len, &_checksum, 1, &checksum) < 0) 951 return (-1); 952 953 if ((checksum & 0xFF) != 0) { 954 return (-1); 955 } 956 957 return (0); 958 } 959 960 static void 961 ihex_write_01(int ofd) 962 { 963 964 ihex_write(ofd, 1, 0, 0, NULL, 0); 965 } 966 967 static void 968 ihex_write_04(int ofd, uint16_t addr) 969 { 970 971 ihex_write(ofd, 4, 0, addr, NULL, 2); 972 } 973 974 static void 975 ihex_write_05(int ofd, uint64_t e_entry) 976 { 977 978 if (e_entry > 0xFFFFFFFF) { 979 warnx("address space too big for Intel Hex file"); 980 return; 981 } 982 983 ihex_write(ofd, 5, 0, e_entry, NULL, 4); 984 } 985 986 static void 987 ihex_write(int ofd, int type, uint64_t addr, uint64_t num, const void *buf, 988 size_t sz) 989 { 990 char line[_LINE_BUFSZ]; 991 const uint8_t *p, *pe; 992 int len, checksum; 993 994 if (sz > 16) 995 errx(EXIT_FAILURE, "Internal: ihex_write() sz too big"); 996 checksum = 0; 997 line[0] = ':'; 998 len = 1; 999 write_num(line, &len, sz, 1, &checksum); 1000 write_num(line, &len, addr, 2, &checksum); 1001 write_num(line, &len, type, 1, &checksum); 1002 if (sz > 0) { 1003 if (buf != NULL) { 1004 for (p = buf, pe = p + sz; p < pe; p++) 1005 write_num(line, &len, *p, 1, &checksum); 1006 } else 1007 write_num(line, &len, num, sz, &checksum); 1008 } 1009 write_num(line, &len, (~checksum + 1) & 0xFF, 1, NULL); 1010 line[len++] = '\r'; 1011 line[len++] = '\n'; 1012 if (write(ofd, line, len) != (ssize_t) len) 1013 err(EXIT_FAILURE, "write failed"); 1014 } 1015 1016 static int 1017 read_num(const char *line, int *len, uint64_t *num, size_t sz, int *checksum) 1018 { 1019 uint8_t b; 1020 1021 *num = 0; 1022 for (; sz > 0; sz--) { 1023 if (!ishexdigit(line[*len]) || !ishexdigit(line[*len + 1])) 1024 return (-1); 1025 b = (hex_value(line[*len]) << 4) | hex_value(line[*len + 1]); 1026 *num = (*num << 8) | b; 1027 *len += 2; 1028 if (checksum != NULL) 1029 *checksum = (*checksum + b) & 0xFF; 1030 } 1031 1032 return (0); 1033 } 1034 1035 static void 1036 write_num(char *line, int *len, uint64_t num, size_t sz, int *checksum) 1037 { 1038 uint8_t b; 1039 1040 for (; sz > 0; sz--) { 1041 b = (num >> ((sz - 1) * 8)) & 0xFF; 1042 line[*len] = hex_digit((b >> 4) & 0xF); 1043 line[*len + 1] = hex_digit(b & 0xF); 1044 *len += 2; 1045 if (checksum != NULL) 1046 *checksum = (*checksum + b) & 0xFF; 1047 } 1048 } 1049 1050 static char 1051 hex_digit(uint8_t n) 1052 { 1053 1054 return ((n < 10) ? '0' + n : 'A' + (n - 10)); 1055 } 1056 1057 static int 1058 hex_value(int x) 1059 { 1060 1061 if (isdigit(x)) 1062 return (x - '0'); 1063 else if (x >= 'a' && x <= 'f') 1064 return (x - 'a' + 10); 1065 else 1066 return (x - 'A' + 10); 1067 } 1068 1069 static int 1070 ishexdigit(int x) 1071 { 1072 1073 if (isdigit(x)) 1074 return (1); 1075 if ((x >= 'a' && x <= 'f') || (x >= 'A' && x <= 'F')) 1076 return (1); 1077 1078 return (0); 1079 } 1080