1 /* BFD back-end for s-record objects. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2011 4 Free Software Foundation, Inc. 5 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>. 6 7 This file is part of BFD, the Binary File Descriptor library. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 22 MA 02110-1301, USA. */ 23 24 25 /* SUBSECTION 26 S-Record handling 27 28 DESCRIPTION 29 30 Ordinary S-Records cannot hold anything but addresses and 31 data, so that's all that we implement. 32 33 The only interesting thing is that S-Records may come out of 34 order and there is no header, so an initial scan is required 35 to discover the minimum and maximum addresses used to create 36 the vma and size of the only section we create. We 37 arbitrarily call this section ".text". 38 39 When bfd_get_section_contents is called the file is read 40 again, and this time the data is placed into a bfd_alloc'd 41 area. 42 43 Any number of sections may be created for output, we save them 44 up and output them when it's time to close the bfd. 45 46 An s record looks like: 47 48 EXAMPLE 49 S<type><length><address><data><checksum> 50 51 DESCRIPTION 52 Where 53 o length 54 is the number of bytes following upto the checksum. Note that 55 this is not the number of chars following, since it takes two 56 chars to represent a byte. 57 o type 58 is one of: 59 0) header record 60 1) two byte address data record 61 2) three byte address data record 62 3) four byte address data record 63 7) four byte address termination record 64 8) three byte address termination record 65 9) two byte address termination record 66 67 o address 68 is the start address of the data following, or in the case of 69 a termination record, the start address of the image 70 o data 71 is the data. 72 o checksum 73 is the sum of all the raw byte data in the record, from the length 74 upwards, modulo 256 and subtracted from 255. 75 76 SUBSECTION 77 Symbol S-Record handling 78 79 DESCRIPTION 80 Some ICE equipment understands an addition to the standard 81 S-Record format; symbols and their addresses can be sent 82 before the data. 83 84 The format of this is: 85 ($$ <modulename> 86 (<space> <symbol> <address>)*) 87 $$ 88 89 so a short symbol table could look like: 90 91 EXAMPLE 92 $$ flash.x 93 $$ flash.c 94 _port6 $0 95 _delay $4 96 _start $14 97 _etext $8036 98 _edata $8036 99 _end $8036 100 $$ 101 102 DESCRIPTION 103 We allow symbols to be anywhere in the data stream - the module names 104 are always ignored. */ 105 106 #include "sysdep.h" 107 #include "bfd.h" 108 #include "libbfd.h" 109 #include "libiberty.h" 110 #include "safe-ctype.h" 111 112 113 /* Macros for converting between hex and binary. */ 114 115 static const char digs[] = "0123456789ABCDEF"; 116 117 #define NIBBLE(x) hex_value(x) 118 #define HEX(buffer) ((NIBBLE ((buffer)[0])<<4) + NIBBLE ((buffer)[1])) 119 #define TOHEX(d, x, ch) \ 120 d[1] = digs[(x) & 0xf]; \ 121 d[0] = digs[((x)>>4)&0xf]; \ 122 ch += ((x) & 0xff); 123 #define ISHEX(x) hex_p(x) 124 125 /* The maximum number of address+data+crc bytes on a line is FF. */ 126 #define MAXCHUNK 0xff 127 128 /* Default size for a CHUNK. */ 129 #define DEFAULT_CHUNK 16 130 131 /* The number of data bytes we actually fit onto a line on output. 132 This variable can be modified by objcopy's --srec-len parameter. 133 For a 0x75 byte record you should set --srec-len=0x70. */ 134 unsigned int Chunk = DEFAULT_CHUNK; 135 136 /* The type of srec output (free or forced to S3). 137 This variable can be modified by objcopy's --srec-forceS3 138 parameter. */ 139 bfd_boolean S3Forced = FALSE; 140 141 /* When writing an S-record file, the S-records can not be output as 142 they are seen. This structure is used to hold them in memory. */ 143 144 struct srec_data_list_struct 145 { 146 struct srec_data_list_struct *next; 147 bfd_byte *data; 148 bfd_vma where; 149 bfd_size_type size; 150 }; 151 152 typedef struct srec_data_list_struct srec_data_list_type; 153 154 /* When scanning the S-record file, a linked list of srec_symbol 155 structures is built to represent the symbol table (if there is 156 one). */ 157 158 struct srec_symbol 159 { 160 struct srec_symbol *next; 161 const char *name; 162 bfd_vma val; 163 }; 164 165 /* The S-record tdata information. */ 166 167 typedef struct srec_data_struct 168 { 169 srec_data_list_type *head; 170 srec_data_list_type *tail; 171 unsigned int type; 172 struct srec_symbol *symbols; 173 struct srec_symbol *symtail; 174 asymbol *csymbols; 175 } 176 tdata_type; 177 178 /* Initialize by filling in the hex conversion array. */ 179 180 static void 181 srec_init (void) 182 { 183 static bfd_boolean inited = FALSE; 184 185 if (! inited) 186 { 187 inited = TRUE; 188 hex_init (); 189 } 190 } 191 192 /* Set up the S-record tdata information. */ 193 194 static bfd_boolean 195 srec_mkobject (bfd *abfd) 196 { 197 tdata_type *tdata; 198 199 srec_init (); 200 201 tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type)); 202 if (tdata == NULL) 203 return FALSE; 204 205 abfd->tdata.srec_data = tdata; 206 tdata->type = 1; 207 tdata->head = NULL; 208 tdata->tail = NULL; 209 tdata->symbols = NULL; 210 tdata->symtail = NULL; 211 tdata->csymbols = NULL; 212 213 return TRUE; 214 } 215 216 /* Read a byte from an S record file. Set *ERRORPTR if an error 217 occurred. Return EOF on error or end of file. */ 218 219 static int 220 srec_get_byte (bfd *abfd, bfd_boolean *errorptr) 221 { 222 bfd_byte c; 223 224 if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1) 225 { 226 if (bfd_get_error () != bfd_error_file_truncated) 227 *errorptr = TRUE; 228 return EOF; 229 } 230 231 return (int) (c & 0xff); 232 } 233 234 /* Report a problem in an S record file. FIXME: This probably should 235 not call fprintf, but we really do need some mechanism for printing 236 error messages. */ 237 238 static void 239 srec_bad_byte (bfd *abfd, 240 unsigned int lineno, 241 int c, 242 bfd_boolean error) 243 { 244 if (c == EOF) 245 { 246 if (! error) 247 bfd_set_error (bfd_error_file_truncated); 248 } 249 else 250 { 251 char buf[10]; 252 253 if (! ISPRINT (c)) 254 sprintf (buf, "\\%03o", (unsigned int) c); 255 else 256 { 257 buf[0] = c; 258 buf[1] = '\0'; 259 } 260 (*_bfd_error_handler) 261 (_("%B:%d: Unexpected character `%s' in S-record file\n"), 262 abfd, lineno, buf); 263 bfd_set_error (bfd_error_bad_value); 264 } 265 } 266 267 /* Add a new symbol found in an S-record file. */ 268 269 static bfd_boolean 270 srec_new_symbol (bfd *abfd, const char *name, bfd_vma val) 271 { 272 struct srec_symbol *n; 273 274 n = (struct srec_symbol *) bfd_alloc (abfd, sizeof (* n)); 275 if (n == NULL) 276 return FALSE; 277 278 n->name = name; 279 n->val = val; 280 281 if (abfd->tdata.srec_data->symbols == NULL) 282 abfd->tdata.srec_data->symbols = n; 283 else 284 abfd->tdata.srec_data->symtail->next = n; 285 abfd->tdata.srec_data->symtail = n; 286 n->next = NULL; 287 288 ++abfd->symcount; 289 290 return TRUE; 291 } 292 293 /* Read the S record file and turn it into sections. We create a new 294 section for each contiguous set of bytes. */ 295 296 static bfd_boolean 297 srec_scan (bfd *abfd) 298 { 299 int c; 300 unsigned int lineno = 1; 301 bfd_boolean error = FALSE; 302 bfd_byte *buf = NULL; 303 size_t bufsize = 0; 304 asection *sec = NULL; 305 char *symbuf = NULL; 306 307 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 308 goto error_return; 309 310 while ((c = srec_get_byte (abfd, &error)) != EOF) 311 { 312 /* We only build sections from contiguous S-records, so if this 313 is not an S-record, then stop building a section. */ 314 if (c != 'S' && c != '\r' && c != '\n') 315 sec = NULL; 316 317 switch (c) 318 { 319 default: 320 srec_bad_byte (abfd, lineno, c, error); 321 goto error_return; 322 323 case '\n': 324 ++lineno; 325 break; 326 327 case '\r': 328 break; 329 330 case '$': 331 /* Starting a module name, which we ignore. */ 332 while ((c = srec_get_byte (abfd, &error)) != '\n' 333 && c != EOF) 334 ; 335 if (c == EOF) 336 { 337 srec_bad_byte (abfd, lineno, c, error); 338 goto error_return; 339 } 340 341 ++lineno; 342 break; 343 344 case ' ': 345 do 346 { 347 bfd_size_type alc; 348 char *p, *symname; 349 bfd_vma symval; 350 351 /* Starting a symbol definition. */ 352 while ((c = srec_get_byte (abfd, &error)) != EOF 353 && (c == ' ' || c == '\t')) 354 ; 355 356 if (c == '\n' || c == '\r') 357 break; 358 359 if (c == EOF) 360 { 361 srec_bad_byte (abfd, lineno, c, error); 362 goto error_return; 363 } 364 365 alc = 10; 366 symbuf = (char *) bfd_malloc (alc + 1); 367 if (symbuf == NULL) 368 goto error_return; 369 370 p = symbuf; 371 372 *p++ = c; 373 while ((c = srec_get_byte (abfd, &error)) != EOF 374 && ! ISSPACE (c)) 375 { 376 if ((bfd_size_type) (p - symbuf) >= alc) 377 { 378 char *n; 379 380 alc *= 2; 381 n = (char *) bfd_realloc (symbuf, alc + 1); 382 if (n == NULL) 383 goto error_return; 384 p = n + (p - symbuf); 385 symbuf = n; 386 } 387 388 *p++ = c; 389 } 390 391 if (c == EOF) 392 { 393 srec_bad_byte (abfd, lineno, c, error); 394 goto error_return; 395 } 396 397 *p++ = '\0'; 398 symname = (char *) bfd_alloc (abfd, (bfd_size_type) (p - symbuf)); 399 if (symname == NULL) 400 goto error_return; 401 strcpy (symname, symbuf); 402 free (symbuf); 403 symbuf = NULL; 404 405 while ((c = srec_get_byte (abfd, &error)) != EOF 406 && (c == ' ' || c == '\t')) 407 ; 408 if (c == EOF) 409 { 410 srec_bad_byte (abfd, lineno, c, error); 411 goto error_return; 412 } 413 414 /* Skip a dollar sign before the hex value. */ 415 if (c == '$') 416 { 417 c = srec_get_byte (abfd, &error); 418 if (c == EOF) 419 { 420 srec_bad_byte (abfd, lineno, c, error); 421 goto error_return; 422 } 423 } 424 425 symval = 0; 426 while (ISHEX (c)) 427 { 428 symval <<= 4; 429 symval += NIBBLE (c); 430 c = srec_get_byte (abfd, &error); 431 if (c == EOF) 432 { 433 srec_bad_byte (abfd, lineno, c, error); 434 goto error_return; 435 } 436 } 437 438 if (! srec_new_symbol (abfd, symname, symval)) 439 goto error_return; 440 } 441 while (c == ' ' || c == '\t') 442 ; 443 444 if (c == '\n') 445 ++lineno; 446 else if (c != '\r') 447 { 448 srec_bad_byte (abfd, lineno, c, error); 449 goto error_return; 450 } 451 452 break; 453 454 case 'S': 455 { 456 file_ptr pos; 457 char hdr[3]; 458 unsigned int bytes; 459 bfd_vma address; 460 bfd_byte *data; 461 unsigned char check_sum; 462 463 /* Starting an S-record. */ 464 465 pos = bfd_tell (abfd) - 1; 466 467 if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3) 468 goto error_return; 469 470 if (! ISHEX (hdr[1]) || ! ISHEX (hdr[2])) 471 { 472 if (! ISHEX (hdr[1])) 473 c = hdr[1]; 474 else 475 c = hdr[2]; 476 srec_bad_byte (abfd, lineno, c, error); 477 goto error_return; 478 } 479 480 check_sum = bytes = HEX (hdr + 1); 481 if (bytes * 2 > bufsize) 482 { 483 if (buf != NULL) 484 free (buf); 485 buf = (bfd_byte *) bfd_malloc ((bfd_size_type) bytes * 2); 486 if (buf == NULL) 487 goto error_return; 488 bufsize = bytes * 2; 489 } 490 491 if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2) 492 goto error_return; 493 494 /* Ignore the checksum byte. */ 495 --bytes; 496 497 address = 0; 498 data = buf; 499 switch (hdr[0]) 500 { 501 case '0': 502 case '5': 503 /* Prologue--ignore the file name, but stop building a 504 section at this point. */ 505 sec = NULL; 506 break; 507 508 case '3': 509 check_sum += HEX (data); 510 address = HEX (data); 511 data += 2; 512 --bytes; 513 /* Fall through. */ 514 case '2': 515 check_sum += HEX (data); 516 address = (address << 8) | HEX (data); 517 data += 2; 518 --bytes; 519 /* Fall through. */ 520 case '1': 521 check_sum += HEX (data); 522 address = (address << 8) | HEX (data); 523 data += 2; 524 check_sum += HEX (data); 525 address = (address << 8) | HEX (data); 526 data += 2; 527 bytes -= 2; 528 529 if (sec != NULL 530 && sec->vma + sec->size == address) 531 { 532 /* This data goes at the end of the section we are 533 currently building. */ 534 sec->size += bytes; 535 } 536 else 537 { 538 char secbuf[20]; 539 char *secname; 540 bfd_size_type amt; 541 flagword flags; 542 543 sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1); 544 amt = strlen (secbuf) + 1; 545 secname = (char *) bfd_alloc (abfd, amt); 546 strcpy (secname, secbuf); 547 flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC; 548 sec = bfd_make_section_with_flags (abfd, secname, flags); 549 if (sec == NULL) 550 goto error_return; 551 sec->vma = address; 552 sec->lma = address; 553 sec->size = bytes; 554 sec->filepos = pos; 555 } 556 557 while (bytes > 0) 558 { 559 check_sum += HEX (data); 560 data += 2; 561 bytes--; 562 } 563 check_sum = 255 - (check_sum & 0xff); 564 if (check_sum != HEX (data)) 565 { 566 (*_bfd_error_handler) 567 (_("%B:%d: Bad checksum in S-record file\n"), 568 abfd, lineno); 569 bfd_set_error (bfd_error_bad_value); 570 goto error_return; 571 } 572 573 break; 574 575 case '7': 576 check_sum += HEX (data); 577 address = HEX (data); 578 data += 2; 579 /* Fall through. */ 580 case '8': 581 check_sum += HEX (data); 582 address = (address << 8) | HEX (data); 583 data += 2; 584 /* Fall through. */ 585 case '9': 586 check_sum += HEX (data); 587 address = (address << 8) | HEX (data); 588 data += 2; 589 check_sum += HEX (data); 590 address = (address << 8) | HEX (data); 591 data += 2; 592 593 /* This is a termination record. */ 594 abfd->start_address = address; 595 596 check_sum = 255 - (check_sum & 0xff); 597 if (check_sum != HEX (data)) 598 { 599 (*_bfd_error_handler) 600 (_("%B:%d: Bad checksum in S-record file\n"), 601 abfd, lineno); 602 bfd_set_error (bfd_error_bad_value); 603 goto error_return; 604 } 605 606 if (buf != NULL) 607 free (buf); 608 609 return TRUE; 610 } 611 } 612 break; 613 } 614 } 615 616 if (error) 617 goto error_return; 618 619 if (buf != NULL) 620 free (buf); 621 622 return TRUE; 623 624 error_return: 625 if (symbuf != NULL) 626 free (symbuf); 627 if (buf != NULL) 628 free (buf); 629 return FALSE; 630 } 631 632 /* Check whether an existing file is an S-record file. */ 633 634 static const bfd_target * 635 srec_object_p (bfd *abfd) 636 { 637 void * tdata_save; 638 bfd_byte b[4]; 639 640 srec_init (); 641 642 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 643 || bfd_bread (b, (bfd_size_type) 4, abfd) != 4) 644 return NULL; 645 646 if (b[0] != 'S' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3])) 647 { 648 bfd_set_error (bfd_error_wrong_format); 649 return NULL; 650 } 651 652 tdata_save = abfd->tdata.any; 653 if (! srec_mkobject (abfd) || ! srec_scan (abfd)) 654 { 655 if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL) 656 bfd_release (abfd, abfd->tdata.any); 657 abfd->tdata.any = tdata_save; 658 return NULL; 659 } 660 661 if (abfd->symcount > 0) 662 abfd->flags |= HAS_SYMS; 663 664 return abfd->xvec; 665 } 666 667 /* Check whether an existing file is an S-record file with symbols. */ 668 669 static const bfd_target * 670 symbolsrec_object_p (bfd *abfd) 671 { 672 void * tdata_save; 673 char b[2]; 674 675 srec_init (); 676 677 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 678 || bfd_bread (b, (bfd_size_type) 2, abfd) != 2) 679 return NULL; 680 681 if (b[0] != '$' || b[1] != '$') 682 { 683 bfd_set_error (bfd_error_wrong_format); 684 return NULL; 685 } 686 687 tdata_save = abfd->tdata.any; 688 if (! srec_mkobject (abfd) || ! srec_scan (abfd)) 689 { 690 if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL) 691 bfd_release (abfd, abfd->tdata.any); 692 abfd->tdata.any = tdata_save; 693 return NULL; 694 } 695 696 if (abfd->symcount > 0) 697 abfd->flags |= HAS_SYMS; 698 699 return abfd->xvec; 700 } 701 702 /* Read in the contents of a section in an S-record file. */ 703 704 static bfd_boolean 705 srec_read_section (bfd *abfd, asection *section, bfd_byte *contents) 706 { 707 int c; 708 bfd_size_type sofar = 0; 709 bfd_boolean error = FALSE; 710 bfd_byte *buf = NULL; 711 size_t bufsize = 0; 712 713 if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0) 714 goto error_return; 715 716 while ((c = srec_get_byte (abfd, &error)) != EOF) 717 { 718 bfd_byte hdr[3]; 719 unsigned int bytes; 720 bfd_vma address; 721 bfd_byte *data; 722 723 if (c == '\r' || c == '\n') 724 continue; 725 726 /* This is called after srec_scan has already been called, so we 727 ought to know the exact format. */ 728 BFD_ASSERT (c == 'S'); 729 730 if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3) 731 goto error_return; 732 733 BFD_ASSERT (ISHEX (hdr[1]) && ISHEX (hdr[2])); 734 735 bytes = HEX (hdr + 1); 736 737 if (bytes * 2 > bufsize) 738 { 739 if (buf != NULL) 740 free (buf); 741 buf = (bfd_byte *) bfd_malloc ((bfd_size_type) bytes * 2); 742 if (buf == NULL) 743 goto error_return; 744 bufsize = bytes * 2; 745 } 746 747 if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2) 748 goto error_return; 749 750 address = 0; 751 data = buf; 752 switch (hdr[0]) 753 { 754 default: 755 BFD_ASSERT (sofar == section->size); 756 if (buf != NULL) 757 free (buf); 758 return TRUE; 759 760 case '3': 761 address = HEX (data); 762 data += 2; 763 --bytes; 764 /* Fall through. */ 765 case '2': 766 address = (address << 8) | HEX (data); 767 data += 2; 768 --bytes; 769 /* Fall through. */ 770 case '1': 771 address = (address << 8) | HEX (data); 772 data += 2; 773 address = (address << 8) | HEX (data); 774 data += 2; 775 bytes -= 2; 776 777 if (address != section->vma + sofar) 778 { 779 /* We've come to the end of this section. */ 780 BFD_ASSERT (sofar == section->size); 781 if (buf != NULL) 782 free (buf); 783 return TRUE; 784 } 785 786 /* Don't consider checksum. */ 787 --bytes; 788 789 while (bytes-- != 0) 790 { 791 contents[sofar] = HEX (data); 792 data += 2; 793 ++sofar; 794 } 795 796 break; 797 } 798 } 799 800 if (error) 801 goto error_return; 802 803 BFD_ASSERT (sofar == section->size); 804 805 if (buf != NULL) 806 free (buf); 807 808 return TRUE; 809 810 error_return: 811 if (buf != NULL) 812 free (buf); 813 return FALSE; 814 } 815 816 /* Get the contents of a section in an S-record file. */ 817 818 static bfd_boolean 819 srec_get_section_contents (bfd *abfd, 820 asection *section, 821 void * location, 822 file_ptr offset, 823 bfd_size_type count) 824 { 825 if (count == 0) 826 return TRUE; 827 828 if (offset + count < count 829 || offset + count > section->size) 830 { 831 bfd_set_error (bfd_error_invalid_operation); 832 return FALSE; 833 } 834 835 if (section->used_by_bfd == NULL) 836 { 837 section->used_by_bfd = bfd_alloc (abfd, section->size); 838 if (section->used_by_bfd == NULL) 839 return FALSE; 840 841 if (! srec_read_section (abfd, section, 842 (bfd_byte *) section->used_by_bfd)) 843 return FALSE; 844 } 845 846 memcpy (location, (bfd_byte *) section->used_by_bfd + offset, 847 (size_t) count); 848 849 return TRUE; 850 } 851 852 /* Set the architecture. We accept an unknown architecture here. */ 853 854 static bfd_boolean 855 srec_set_arch_mach (bfd *abfd, enum bfd_architecture arch, unsigned long mach) 856 { 857 if (arch != bfd_arch_unknown) 858 return bfd_default_set_arch_mach (abfd, arch, mach); 859 860 abfd->arch_info = & bfd_default_arch_struct; 861 return TRUE; 862 } 863 864 /* We have to save up all the Srecords for a splurge before output. */ 865 866 static bfd_boolean 867 srec_set_section_contents (bfd *abfd, 868 sec_ptr section, 869 const void * location, 870 file_ptr offset, 871 bfd_size_type bytes_to_do) 872 { 873 tdata_type *tdata = abfd->tdata.srec_data; 874 srec_data_list_type *entry; 875 876 entry = (srec_data_list_type *) bfd_alloc (abfd, sizeof (* entry)); 877 if (entry == NULL) 878 return FALSE; 879 880 if (bytes_to_do 881 && (section->flags & SEC_ALLOC) 882 && (section->flags & SEC_LOAD)) 883 { 884 bfd_byte *data; 885 886 data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do); 887 if (data == NULL) 888 return FALSE; 889 memcpy ((void *) data, location, (size_t) bytes_to_do); 890 891 /* Ff S3Forced is TRUE then always select S3 records, 892 regardless of the siez of the addresses. */ 893 if (S3Forced) 894 tdata->type = 3; 895 else if ((section->lma + offset + bytes_to_do - 1) <= 0xffff) 896 ; /* The default, S1, is OK. */ 897 else if ((section->lma + offset + bytes_to_do - 1) <= 0xffffff 898 && tdata->type <= 2) 899 tdata->type = 2; 900 else 901 tdata->type = 3; 902 903 entry->data = data; 904 entry->where = section->lma + offset; 905 entry->size = bytes_to_do; 906 907 /* Sort the records by address. Optimize for the common case of 908 adding a record to the end of the list. */ 909 if (tdata->tail != NULL 910 && entry->where >= tdata->tail->where) 911 { 912 tdata->tail->next = entry; 913 entry->next = NULL; 914 tdata->tail = entry; 915 } 916 else 917 { 918 srec_data_list_type **look; 919 920 for (look = &tdata->head; 921 *look != NULL && (*look)->where < entry->where; 922 look = &(*look)->next) 923 ; 924 entry->next = *look; 925 *look = entry; 926 if (entry->next == NULL) 927 tdata->tail = entry; 928 } 929 } 930 return TRUE; 931 } 932 933 /* Write a record of type, of the supplied number of bytes. The 934 supplied bytes and length don't have a checksum. That's worked out 935 here. */ 936 937 static bfd_boolean 938 srec_write_record (bfd *abfd, 939 unsigned int type, 940 bfd_vma address, 941 const bfd_byte *data, 942 const bfd_byte *end) 943 { 944 char buffer[2 * MAXCHUNK + 6]; 945 unsigned int check_sum = 0; 946 const bfd_byte *src = data; 947 char *dst = buffer; 948 char *length; 949 bfd_size_type wrlen; 950 951 *dst++ = 'S'; 952 *dst++ = '0' + type; 953 954 length = dst; 955 dst += 2; /* Leave room for dst. */ 956 957 switch (type) 958 { 959 case 3: 960 case 7: 961 TOHEX (dst, (address >> 24), check_sum); 962 dst += 2; 963 case 8: 964 case 2: 965 TOHEX (dst, (address >> 16), check_sum); 966 dst += 2; 967 case 9: 968 case 1: 969 case 0: 970 TOHEX (dst, (address >> 8), check_sum); 971 dst += 2; 972 TOHEX (dst, (address), check_sum); 973 dst += 2; 974 break; 975 976 } 977 for (src = data; src < end; src++) 978 { 979 TOHEX (dst, *src, check_sum); 980 dst += 2; 981 } 982 983 /* Fill in the length. */ 984 TOHEX (length, (dst - length) / 2, check_sum); 985 check_sum &= 0xff; 986 check_sum = 255 - check_sum; 987 TOHEX (dst, check_sum, check_sum); 988 dst += 2; 989 990 *dst++ = '\r'; 991 *dst++ = '\n'; 992 wrlen = dst - buffer; 993 994 return bfd_bwrite ((void *) buffer, wrlen, abfd) == wrlen; 995 } 996 997 static bfd_boolean 998 srec_write_header (bfd *abfd) 999 { 1000 unsigned int len = strlen (abfd->filename); 1001 1002 /* I'll put an arbitrary 40 char limit on header size. */ 1003 if (len > 40) 1004 len = 40; 1005 1006 return srec_write_record (abfd, 0, (bfd_vma) 0, 1007 (bfd_byte *) abfd->filename, 1008 (bfd_byte *) abfd->filename + len); 1009 } 1010 1011 static bfd_boolean 1012 srec_write_section (bfd *abfd, 1013 tdata_type *tdata, 1014 srec_data_list_type *list) 1015 { 1016 unsigned int octets_written = 0; 1017 bfd_byte *location = list->data; 1018 1019 /* Validate number of data bytes to write. The srec length byte 1020 counts the address, data and crc bytes. S1 (tdata->type == 1) 1021 records have two address bytes, S2 (tdata->type == 2) records 1022 have three, and S3 (tdata->type == 3) records have four. 1023 The total length can't exceed 255, and a zero data length will 1024 spin for a long time. */ 1025 if (Chunk == 0) 1026 Chunk = 1; 1027 else if (Chunk > MAXCHUNK - tdata->type - 2) 1028 Chunk = MAXCHUNK - tdata->type - 2; 1029 1030 while (octets_written < list->size) 1031 { 1032 bfd_vma address; 1033 unsigned int octets_this_chunk = list->size - octets_written; 1034 1035 if (octets_this_chunk > Chunk) 1036 octets_this_chunk = Chunk; 1037 1038 address = list->where + octets_written / bfd_octets_per_byte (abfd); 1039 1040 if (! srec_write_record (abfd, 1041 tdata->type, 1042 address, 1043 location, 1044 location + octets_this_chunk)) 1045 return FALSE; 1046 1047 octets_written += octets_this_chunk; 1048 location += octets_this_chunk; 1049 } 1050 1051 return TRUE; 1052 } 1053 1054 static bfd_boolean 1055 srec_write_terminator (bfd *abfd, tdata_type *tdata) 1056 { 1057 return srec_write_record (abfd, 10 - tdata->type, 1058 abfd->start_address, NULL, NULL); 1059 } 1060 1061 static bfd_boolean 1062 srec_write_symbols (bfd *abfd) 1063 { 1064 /* Dump out the symbols of a bfd. */ 1065 int i; 1066 int count = bfd_get_symcount (abfd); 1067 1068 if (count) 1069 { 1070 bfd_size_type len; 1071 asymbol **table = bfd_get_outsymbols (abfd); 1072 1073 len = strlen (abfd->filename); 1074 if (bfd_bwrite ("$$ ", (bfd_size_type) 3, abfd) != 3 1075 || bfd_bwrite (abfd->filename, len, abfd) != len 1076 || bfd_bwrite ("\r\n", (bfd_size_type) 2, abfd) != 2) 1077 return FALSE; 1078 1079 for (i = 0; i < count; i++) 1080 { 1081 asymbol *s = table[i]; 1082 if (! bfd_is_local_label (abfd, s) 1083 && (s->flags & BSF_DEBUGGING) == 0) 1084 { 1085 /* Just dump out non debug symbols. */ 1086 char buf[43], *p; 1087 1088 len = strlen (s->name); 1089 if (bfd_bwrite (" ", (bfd_size_type) 2, abfd) != 2 1090 || bfd_bwrite (s->name, len, abfd) != len) 1091 return FALSE; 1092 1093 sprintf_vma (buf + 2, (s->value 1094 + s->section->output_section->lma 1095 + s->section->output_offset)); 1096 p = buf + 2; 1097 while (p[0] == '0' && p[1] != 0) 1098 p++; 1099 len = strlen (p); 1100 p[len] = '\r'; 1101 p[len + 1] = '\n'; 1102 *--p = '$'; 1103 *--p = ' '; 1104 len += 4; 1105 if (bfd_bwrite (p, len, abfd) != len) 1106 return FALSE; 1107 } 1108 } 1109 if (bfd_bwrite ("$$ \r\n", (bfd_size_type) 5, abfd) != 5) 1110 return FALSE; 1111 } 1112 1113 return TRUE; 1114 } 1115 1116 static bfd_boolean 1117 internal_srec_write_object_contents (bfd *abfd, int symbols) 1118 { 1119 tdata_type *tdata = abfd->tdata.srec_data; 1120 srec_data_list_type *list; 1121 1122 if (symbols) 1123 { 1124 if (! srec_write_symbols (abfd)) 1125 return FALSE; 1126 } 1127 1128 if (! srec_write_header (abfd)) 1129 return FALSE; 1130 1131 /* Now wander though all the sections provided and output them. */ 1132 list = tdata->head; 1133 1134 while (list != (srec_data_list_type *) NULL) 1135 { 1136 if (! srec_write_section (abfd, tdata, list)) 1137 return FALSE; 1138 list = list->next; 1139 } 1140 return srec_write_terminator (abfd, tdata); 1141 } 1142 1143 static bfd_boolean 1144 srec_write_object_contents (bfd *abfd) 1145 { 1146 return internal_srec_write_object_contents (abfd, 0); 1147 } 1148 1149 static bfd_boolean 1150 symbolsrec_write_object_contents (bfd *abfd) 1151 { 1152 return internal_srec_write_object_contents (abfd, 1); 1153 } 1154 1155 static int 1156 srec_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED, 1157 struct bfd_link_info *info ATTRIBUTE_UNUSED) 1158 { 1159 return 0; 1160 } 1161 1162 /* Return the amount of memory needed to read the symbol table. */ 1163 1164 static long 1165 srec_get_symtab_upper_bound (bfd *abfd) 1166 { 1167 return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *); 1168 } 1169 1170 /* Return the symbol table. */ 1171 1172 static long 1173 srec_canonicalize_symtab (bfd *abfd, asymbol **alocation) 1174 { 1175 bfd_size_type symcount = bfd_get_symcount (abfd); 1176 asymbol *csymbols; 1177 unsigned int i; 1178 1179 csymbols = abfd->tdata.srec_data->csymbols; 1180 if (csymbols == NULL && symcount != 0) 1181 { 1182 asymbol *c; 1183 struct srec_symbol *s; 1184 1185 csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol)); 1186 if (csymbols == NULL) 1187 return -1; 1188 abfd->tdata.srec_data->csymbols = csymbols; 1189 1190 for (s = abfd->tdata.srec_data->symbols, c = csymbols; 1191 s != NULL; 1192 s = s->next, ++c) 1193 { 1194 c->the_bfd = abfd; 1195 c->name = s->name; 1196 c->value = s->val; 1197 c->flags = BSF_GLOBAL; 1198 c->section = bfd_abs_section_ptr; 1199 c->udata.p = NULL; 1200 } 1201 } 1202 1203 for (i = 0; i < symcount; i++) 1204 *alocation++ = csymbols++; 1205 *alocation = NULL; 1206 1207 return symcount; 1208 } 1209 1210 static void 1211 srec_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED, 1212 asymbol *symbol, 1213 symbol_info *ret) 1214 { 1215 bfd_symbol_info (symbol, ret); 1216 } 1217 1218 static void 1219 srec_print_symbol (bfd *abfd, 1220 void * afile, 1221 asymbol *symbol, 1222 bfd_print_symbol_type how) 1223 { 1224 FILE *file = (FILE *) afile; 1225 1226 switch (how) 1227 { 1228 case bfd_print_symbol_name: 1229 fprintf (file, "%s", symbol->name); 1230 break; 1231 default: 1232 bfd_print_symbol_vandf (abfd, (void *) file, symbol); 1233 fprintf (file, " %-5s %s", 1234 symbol->section->name, 1235 symbol->name); 1236 } 1237 } 1238 1239 #define srec_close_and_cleanup _bfd_generic_close_and_cleanup 1240 #define srec_bfd_free_cached_info _bfd_generic_bfd_free_cached_info 1241 #define srec_new_section_hook _bfd_generic_new_section_hook 1242 #define srec_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false) 1243 #define srec_bfd_is_local_label_name bfd_generic_is_local_label_name 1244 #define srec_get_lineno _bfd_nosymbols_get_lineno 1245 #define srec_find_nearest_line _bfd_nosymbols_find_nearest_line 1246 #define srec_find_inliner_info _bfd_nosymbols_find_inliner_info 1247 #define srec_make_empty_symbol _bfd_generic_make_empty_symbol 1248 #define srec_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol 1249 #define srec_read_minisymbols _bfd_generic_read_minisymbols 1250 #define srec_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol 1251 #define srec_get_section_contents_in_window _bfd_generic_get_section_contents_in_window 1252 #define srec_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents 1253 #define srec_bfd_relax_section bfd_generic_relax_section 1254 #define srec_bfd_gc_sections bfd_generic_gc_sections 1255 #define srec_bfd_lookup_section_flags bfd_generic_lookup_section_flags 1256 #define srec_bfd_merge_sections bfd_generic_merge_sections 1257 #define srec_bfd_is_group_section bfd_generic_is_group_section 1258 #define srec_bfd_discard_group bfd_generic_discard_group 1259 #define srec_section_already_linked _bfd_generic_section_already_linked 1260 #define srec_bfd_define_common_symbol bfd_generic_define_common_symbol 1261 #define srec_bfd_link_hash_table_create _bfd_generic_link_hash_table_create 1262 #define srec_bfd_link_hash_table_free _bfd_generic_link_hash_table_free 1263 #define srec_bfd_link_add_symbols _bfd_generic_link_add_symbols 1264 #define srec_bfd_link_just_syms _bfd_generic_link_just_syms 1265 #define srec_bfd_copy_link_hash_symbol_type \ 1266 _bfd_generic_copy_link_hash_symbol_type 1267 #define srec_bfd_final_link _bfd_generic_final_link 1268 #define srec_bfd_link_split_section _bfd_generic_link_split_section 1269 1270 const bfd_target srec_vec = 1271 { 1272 "srec", /* Name. */ 1273 bfd_target_srec_flavour, 1274 BFD_ENDIAN_UNKNOWN, /* Target byte order. */ 1275 BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */ 1276 (HAS_RELOC | EXEC_P | /* Object flags. */ 1277 HAS_LINENO | HAS_DEBUG | 1278 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED), 1279 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS 1280 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */ 1281 0, /* Leading underscore. */ 1282 ' ', /* AR_pad_char. */ 1283 16, /* AR_max_namelen. */ 1284 0, /* match priority. */ 1285 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1286 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1287 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */ 1288 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1289 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1290 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Hdrs. */ 1291 1292 { 1293 _bfd_dummy_target, 1294 srec_object_p, /* bfd_check_format. */ 1295 _bfd_dummy_target, 1296 _bfd_dummy_target, 1297 }, 1298 { 1299 bfd_false, 1300 srec_mkobject, 1301 _bfd_generic_mkarchive, 1302 bfd_false, 1303 }, 1304 { /* bfd_write_contents. */ 1305 bfd_false, 1306 srec_write_object_contents, 1307 _bfd_write_archive_contents, 1308 bfd_false, 1309 }, 1310 1311 BFD_JUMP_TABLE_GENERIC (srec), 1312 BFD_JUMP_TABLE_COPY (_bfd_generic), 1313 BFD_JUMP_TABLE_CORE (_bfd_nocore), 1314 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), 1315 BFD_JUMP_TABLE_SYMBOLS (srec), 1316 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), 1317 BFD_JUMP_TABLE_WRITE (srec), 1318 BFD_JUMP_TABLE_LINK (srec), 1319 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 1320 1321 NULL, 1322 1323 NULL 1324 }; 1325 1326 const bfd_target symbolsrec_vec = 1327 { 1328 "symbolsrec", /* Name. */ 1329 bfd_target_srec_flavour, 1330 BFD_ENDIAN_UNKNOWN, /* Target byte order. */ 1331 BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */ 1332 (HAS_RELOC | EXEC_P | /* Object flags. */ 1333 HAS_LINENO | HAS_DEBUG | 1334 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED), 1335 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS 1336 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */ 1337 0, /* Leading underscore. */ 1338 ' ', /* AR_pad_char. */ 1339 16, /* AR_max_namelen. */ 1340 0, /* match priority. */ 1341 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1342 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1343 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */ 1344 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1345 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1346 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */ 1347 1348 { 1349 _bfd_dummy_target, 1350 symbolsrec_object_p, /* bfd_check_format. */ 1351 _bfd_dummy_target, 1352 _bfd_dummy_target, 1353 }, 1354 { 1355 bfd_false, 1356 srec_mkobject, 1357 _bfd_generic_mkarchive, 1358 bfd_false, 1359 }, 1360 { /* bfd_write_contents. */ 1361 bfd_false, 1362 symbolsrec_write_object_contents, 1363 _bfd_write_archive_contents, 1364 bfd_false, 1365 }, 1366 1367 BFD_JUMP_TABLE_GENERIC (srec), 1368 BFD_JUMP_TABLE_COPY (_bfd_generic), 1369 BFD_JUMP_TABLE_CORE (_bfd_nocore), 1370 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), 1371 BFD_JUMP_TABLE_SYMBOLS (srec), 1372 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), 1373 BFD_JUMP_TABLE_WRITE (srec), 1374 BFD_JUMP_TABLE_LINK (srec), 1375 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 1376 1377 NULL, 1378 1379 NULL 1380 }; 1381