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