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 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 2 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, MA 02110-1301, USA. */ 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 113static 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. */ 132unsigned 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. */ 137bfd_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 142struct 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 150typedef 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 156struct 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 165typedef 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 } 174tdata_type; 175 176/* Initialize by filling in the hex conversion array. */ 177 178static void 179srec_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 192static bfd_boolean 193srec_mkobject (bfd *abfd) 194{ 195 tdata_type *tdata; 196 197 srec_init (); 198 199 tdata = 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 217static int 218srec_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 236static void 237srec_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[10]; 250 251 if (! ISPRINT (c)) 252 sprintf (buf, "\\%03o", (unsigned int) c); 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 267static bfd_boolean 268srec_new_symbol (bfd *abfd, const char *name, bfd_vma val) 269{ 270 struct srec_symbol *n; 271 272 n = 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 294static bfd_boolean 295srec_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 = 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 = 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 = 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 } 430 431 if (! srec_new_symbol (abfd, symname, symval)) 432 goto error_return; 433 } 434 while (c == ' ' || c == '\t') 435 ; 436 437 if (c == '\n') 438 ++lineno; 439 else if (c != '\r') 440 { 441 srec_bad_byte (abfd, lineno, c, error); 442 goto error_return; 443 } 444 445 break; 446 447 case 'S': 448 { 449 file_ptr pos; 450 char hdr[3]; 451 unsigned int bytes; 452 bfd_vma address; 453 bfd_byte *data; 454 455 /* Starting an S-record. */ 456 457 pos = bfd_tell (abfd) - 1; 458 459 if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3) 460 goto error_return; 461 462 if (! ISHEX (hdr[1]) || ! ISHEX (hdr[2])) 463 { 464 if (! ISHEX (hdr[1])) 465 c = hdr[1]; 466 else 467 c = hdr[2]; 468 srec_bad_byte (abfd, lineno, c, error); 469 goto error_return; 470 } 471 472 bytes = HEX (hdr + 1); 473 if (bytes * 2 > bufsize) 474 { 475 if (buf != NULL) 476 free (buf); 477 buf = bfd_malloc ((bfd_size_type) bytes * 2); 478 if (buf == NULL) 479 goto error_return; 480 bufsize = bytes * 2; 481 } 482 483 if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2) 484 goto error_return; 485 486 /* Ignore the checksum byte. */ 487 --bytes; 488 489 address = 0; 490 data = buf; 491 switch (hdr[0]) 492 { 493 case '0': 494 case '5': 495 /* Prologue--ignore the file name, but stop building a 496 section at this point. */ 497 sec = NULL; 498 break; 499 500 case '3': 501 address = HEX (data); 502 data += 2; 503 --bytes; 504 /* Fall through. */ 505 case '2': 506 address = (address << 8) | HEX (data); 507 data += 2; 508 --bytes; 509 /* Fall through. */ 510 case '1': 511 address = (address << 8) | HEX (data); 512 data += 2; 513 address = (address << 8) | HEX (data); 514 data += 2; 515 bytes -= 2; 516 517 if (sec != NULL 518 && sec->vma + sec->size == address) 519 { 520 /* This data goes at the end of the section we are 521 currently building. */ 522 sec->size += bytes; 523 } 524 else 525 { 526 char secbuf[20]; 527 char *secname; 528 bfd_size_type amt; 529 flagword flags; 530 531 sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1); 532 amt = strlen (secbuf) + 1; 533 secname = bfd_alloc (abfd, amt); 534 strcpy (secname, secbuf); 535 flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC; 536 sec = bfd_make_section_with_flags (abfd, secname, flags); 537 if (sec == NULL) 538 goto error_return; 539 sec->vma = address; 540 sec->lma = address; 541 sec->size = bytes; 542 sec->filepos = pos; 543 } 544 break; 545 546 case '7': 547 address = HEX (data); 548 data += 2; 549 /* Fall through. */ 550 case '8': 551 address = (address << 8) | HEX (data); 552 data += 2; 553 /* Fall through. */ 554 case '9': 555 address = (address << 8) | HEX (data); 556 data += 2; 557 address = (address << 8) | HEX (data); 558 data += 2; 559 560 /* This is a termination record. */ 561 abfd->start_address = address; 562 563 if (buf != NULL) 564 free (buf); 565 566 return TRUE; 567 } 568 } 569 break; 570 } 571 } 572 573 if (error) 574 goto error_return; 575 576 if (buf != NULL) 577 free (buf); 578 579 return TRUE; 580 581 error_return: 582 if (symbuf != NULL) 583 free (symbuf); 584 if (buf != NULL) 585 free (buf); 586 return FALSE; 587} 588 589/* Check whether an existing file is an S-record file. */ 590 591static const bfd_target * 592srec_object_p (bfd *abfd) 593{ 594 void * tdata_save; 595 bfd_byte b[4]; 596 597 srec_init (); 598 599 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 600 || bfd_bread (b, (bfd_size_type) 4, abfd) != 4) 601 return NULL; 602 603 if (b[0] != 'S' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3])) 604 { 605 bfd_set_error (bfd_error_wrong_format); 606 return NULL; 607 } 608 609 tdata_save = abfd->tdata.any; 610 if (! srec_mkobject (abfd) || ! srec_scan (abfd)) 611 { 612 if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL) 613 bfd_release (abfd, abfd->tdata.any); 614 abfd->tdata.any = tdata_save; 615 return NULL; 616 } 617 618 if (abfd->symcount > 0) 619 abfd->flags |= HAS_SYMS; 620 621 return abfd->xvec; 622} 623 624/* Check whether an existing file is an S-record file with symbols. */ 625 626static const bfd_target * 627symbolsrec_object_p (bfd *abfd) 628{ 629 void * tdata_save; 630 char b[2]; 631 632 srec_init (); 633 634 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 635 || bfd_bread (b, (bfd_size_type) 2, abfd) != 2) 636 return NULL; 637 638 if (b[0] != '$' || b[1] != '$') 639 { 640 bfd_set_error (bfd_error_wrong_format); 641 return NULL; 642 } 643 644 tdata_save = abfd->tdata.any; 645 if (! srec_mkobject (abfd) || ! srec_scan (abfd)) 646 { 647 if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL) 648 bfd_release (abfd, abfd->tdata.any); 649 abfd->tdata.any = tdata_save; 650 return NULL; 651 } 652 653 if (abfd->symcount > 0) 654 abfd->flags |= HAS_SYMS; 655 656 return abfd->xvec; 657} 658 659/* Read in the contents of a section in an S-record file. */ 660 661static bfd_boolean 662srec_read_section (bfd *abfd, asection *section, bfd_byte *contents) 663{ 664 int c; 665 bfd_size_type sofar = 0; 666 bfd_boolean error = FALSE; 667 bfd_byte *buf = NULL; 668 size_t bufsize = 0; 669 670 if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0) 671 goto error_return; 672 673 while ((c = srec_get_byte (abfd, &error)) != EOF) 674 { 675 bfd_byte hdr[3]; 676 unsigned int bytes; 677 bfd_vma address; 678 bfd_byte *data; 679 680 if (c == '\r' || c == '\n') 681 continue; 682 683 /* This is called after srec_scan has already been called, so we 684 ought to know the exact format. */ 685 BFD_ASSERT (c == 'S'); 686 687 if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3) 688 goto error_return; 689 690 BFD_ASSERT (ISHEX (hdr[1]) && ISHEX (hdr[2])); 691 692 bytes = HEX (hdr + 1); 693 694 if (bytes * 2 > bufsize) 695 { 696 if (buf != NULL) 697 free (buf); 698 buf = bfd_malloc ((bfd_size_type) bytes * 2); 699 if (buf == NULL) 700 goto error_return; 701 bufsize = bytes * 2; 702 } 703 704 if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2) 705 goto error_return; 706 707 address = 0; 708 data = buf; 709 switch (hdr[0]) 710 { 711 default: 712 BFD_ASSERT (sofar == section->size); 713 if (buf != NULL) 714 free (buf); 715 return TRUE; 716 717 case '3': 718 address = HEX (data); 719 data += 2; 720 --bytes; 721 /* Fall through. */ 722 case '2': 723 address = (address << 8) | HEX (data); 724 data += 2; 725 --bytes; 726 /* Fall through. */ 727 case '1': 728 address = (address << 8) | HEX (data); 729 data += 2; 730 address = (address << 8) | HEX (data); 731 data += 2; 732 bytes -= 2; 733 734 if (address != section->vma + sofar) 735 { 736 /* We've come to the end of this section. */ 737 BFD_ASSERT (sofar == section->size); 738 if (buf != NULL) 739 free (buf); 740 return TRUE; 741 } 742 743 /* Don't consider checksum. */ 744 --bytes; 745 746 while (bytes-- != 0) 747 { 748 contents[sofar] = HEX (data); 749 data += 2; 750 ++sofar; 751 } 752 753 break; 754 } 755 } 756 757 if (error) 758 goto error_return; 759 760 BFD_ASSERT (sofar == section->size); 761 762 if (buf != NULL) 763 free (buf); 764 765 return TRUE; 766 767 error_return: 768 if (buf != NULL) 769 free (buf); 770 return FALSE; 771} 772 773/* Get the contents of a section in an S-record file. */ 774 775static bfd_boolean 776srec_get_section_contents (bfd *abfd, 777 asection *section, 778 void * location, 779 file_ptr offset, 780 bfd_size_type count) 781{ 782 if (section->used_by_bfd == NULL) 783 { 784 section->used_by_bfd = bfd_alloc (abfd, section->size); 785 if (section->used_by_bfd == NULL && section->size != 0) 786 return FALSE; 787 788 if (! srec_read_section (abfd, section, section->used_by_bfd)) 789 return FALSE; 790 } 791 792 memcpy (location, (bfd_byte *) section->used_by_bfd + offset, 793 (size_t) count); 794 795 return TRUE; 796} 797 798/* Set the architecture. We accept an unknown architecture here. */ 799 800static bfd_boolean 801srec_set_arch_mach (bfd *abfd, enum bfd_architecture arch, unsigned long mach) 802{ 803 if (arch != bfd_arch_unknown) 804 return bfd_default_set_arch_mach (abfd, arch, mach); 805 806 abfd->arch_info = & bfd_default_arch_struct; 807 return TRUE; 808} 809 810/* We have to save up all the Srecords for a splurge before output. */ 811 812static bfd_boolean 813srec_set_section_contents (bfd *abfd, 814 sec_ptr section, 815 const void * location, 816 file_ptr offset, 817 bfd_size_type bytes_to_do) 818{ 819 tdata_type *tdata = abfd->tdata.srec_data; 820 srec_data_list_type *entry; 821 822 entry = bfd_alloc (abfd, sizeof (* entry)); 823 if (entry == NULL) 824 return FALSE; 825 826 if (bytes_to_do 827 && (section->flags & SEC_ALLOC) 828 && (section->flags & SEC_LOAD)) 829 { 830 bfd_byte *data; 831 832 data = bfd_alloc (abfd, bytes_to_do); 833 if (data == NULL) 834 return FALSE; 835 memcpy ((void *) data, location, (size_t) bytes_to_do); 836 837 /* Ff S3Forced is TRUE then always select S3 records, 838 regardless of the siez of the addresses. */ 839 if (S3Forced) 840 tdata->type = 3; 841 else if ((section->lma + offset + bytes_to_do - 1) <= 0xffff) 842 ; /* The default, S1, is OK. */ 843 else if ((section->lma + offset + bytes_to_do - 1) <= 0xffffff 844 && tdata->type <= 2) 845 tdata->type = 2; 846 else 847 tdata->type = 3; 848 849 entry->data = data; 850 entry->where = section->lma + offset; 851 entry->size = bytes_to_do; 852 853 /* Sort the records by address. Optimize for the common case of 854 adding a record to the end of the list. */ 855 if (tdata->tail != NULL 856 && entry->where >= tdata->tail->where) 857 { 858 tdata->tail->next = entry; 859 entry->next = NULL; 860 tdata->tail = entry; 861 } 862 else 863 { 864 srec_data_list_type **look; 865 866 for (look = &tdata->head; 867 *look != NULL && (*look)->where < entry->where; 868 look = &(*look)->next) 869 ; 870 entry->next = *look; 871 *look = entry; 872 if (entry->next == NULL) 873 tdata->tail = entry; 874 } 875 } 876 return TRUE; 877} 878 879/* Write a record of type, of the supplied number of bytes. The 880 supplied bytes and length don't have a checksum. That's worked out 881 here. */ 882 883static bfd_boolean 884srec_write_record (bfd *abfd, 885 unsigned int type, 886 bfd_vma address, 887 const bfd_byte *data, 888 const bfd_byte *end) 889{ 890 char buffer[2 * MAXCHUNK + 6]; 891 unsigned int check_sum = 0; 892 const bfd_byte *src = data; 893 char *dst = buffer; 894 char *length; 895 bfd_size_type wrlen; 896 897 *dst++ = 'S'; 898 *dst++ = '0' + type; 899 900 length = dst; 901 dst += 2; /* Leave room for dst. */ 902 903 switch (type) 904 { 905 case 3: 906 case 7: 907 TOHEX (dst, (address >> 24), check_sum); 908 dst += 2; 909 case 8: 910 case 2: 911 TOHEX (dst, (address >> 16), check_sum); 912 dst += 2; 913 case 9: 914 case 1: 915 case 0: 916 TOHEX (dst, (address >> 8), check_sum); 917 dst += 2; 918 TOHEX (dst, (address), check_sum); 919 dst += 2; 920 break; 921 922 } 923 for (src = data; src < end; src++) 924 { 925 TOHEX (dst, *src, check_sum); 926 dst += 2; 927 } 928 929 /* Fill in the length. */ 930 TOHEX (length, (dst - length) / 2, check_sum); 931 check_sum &= 0xff; 932 check_sum = 255 - check_sum; 933 TOHEX (dst, check_sum, check_sum); 934 dst += 2; 935 936 *dst++ = '\r'; 937 *dst++ = '\n'; 938 wrlen = dst - buffer; 939 940 return bfd_bwrite ((void *) buffer, wrlen, abfd) == wrlen; 941} 942 943static bfd_boolean 944srec_write_header (bfd *abfd) 945{ 946 unsigned int len = strlen (abfd->filename); 947 948 /* I'll put an arbitrary 40 char limit on header size. */ 949 if (len > 40) 950 len = 40; 951 952 return srec_write_record (abfd, 0, (bfd_vma) 0, 953 (bfd_byte *) abfd->filename, 954 (bfd_byte *) abfd->filename + len); 955} 956 957static bfd_boolean 958srec_write_section (bfd *abfd, 959 tdata_type *tdata, 960 srec_data_list_type *list) 961{ 962 unsigned int octets_written = 0; 963 bfd_byte *location = list->data; 964 965 /* Validate number of data bytes to write. The srec length byte 966 counts the address, data and crc bytes. S1 (tdata->type == 1) 967 records have two address bytes, S2 (tdata->type == 2) records 968 have three, and S3 (tdata->type == 3) records have four. 969 The total length can't exceed 255, and a zero data length will 970 spin for a long time. */ 971 if (Chunk == 0) 972 Chunk = 1; 973 else if (Chunk > MAXCHUNK - tdata->type - 2) 974 Chunk = MAXCHUNK - tdata->type - 2; 975 976 while (octets_written < list->size) 977 { 978 bfd_vma address; 979 unsigned int octets_this_chunk = list->size - octets_written; 980 981 if (octets_this_chunk > Chunk) 982 octets_this_chunk = Chunk; 983 984 address = list->where + octets_written / bfd_octets_per_byte (abfd); 985 986 if (! srec_write_record (abfd, 987 tdata->type, 988 address, 989 location, 990 location + octets_this_chunk)) 991 return FALSE; 992 993 octets_written += octets_this_chunk; 994 location += octets_this_chunk; 995 } 996 997 return TRUE; 998} 999 1000static bfd_boolean 1001srec_write_terminator (bfd *abfd, tdata_type *tdata) 1002{ 1003 return srec_write_record (abfd, 10 - tdata->type, 1004 abfd->start_address, NULL, NULL); 1005} 1006 1007static bfd_boolean 1008srec_write_symbols (bfd *abfd) 1009{ 1010 /* Dump out the symbols of a bfd. */ 1011 int i; 1012 int count = bfd_get_symcount (abfd); 1013 1014 if (count) 1015 { 1016 bfd_size_type len; 1017 asymbol **table = bfd_get_outsymbols (abfd); 1018 1019 len = strlen (abfd->filename); 1020 if (bfd_bwrite ("$$ ", (bfd_size_type) 3, abfd) != 3 1021 || bfd_bwrite (abfd->filename, len, abfd) != len 1022 || bfd_bwrite ("\r\n", (bfd_size_type) 2, abfd) != 2) 1023 return FALSE; 1024 1025 for (i = 0; i < count; i++) 1026 { 1027 asymbol *s = table[i]; 1028 if (! bfd_is_local_label (abfd, s) 1029 && (s->flags & BSF_DEBUGGING) == 0) 1030 { 1031 /* Just dump out non debug symbols. */ 1032 char buf[43], *p; 1033 1034 len = strlen (s->name); 1035 if (bfd_bwrite (" ", (bfd_size_type) 2, abfd) != 2 1036 || bfd_bwrite (s->name, len, abfd) != len) 1037 return FALSE; 1038 1039 sprintf_vma (buf + 2, (s->value 1040 + s->section->output_section->lma 1041 + s->section->output_offset)); 1042 p = buf + 2; 1043 while (p[0] == '0' && p[1] != 0) 1044 p++; 1045 len = strlen (p); 1046 p[len] = '\r'; 1047 p[len + 1] = '\n'; 1048 *--p = '$'; 1049 *--p = ' '; 1050 len += 4; 1051 if (bfd_bwrite (p, len, abfd) != len) 1052 return FALSE; 1053 } 1054 } 1055 if (bfd_bwrite ("$$ \r\n", (bfd_size_type) 5, abfd) != 5) 1056 return FALSE; 1057 } 1058 1059 return TRUE; 1060} 1061 1062static bfd_boolean 1063internal_srec_write_object_contents (bfd *abfd, int symbols) 1064{ 1065 tdata_type *tdata = abfd->tdata.srec_data; 1066 srec_data_list_type *list; 1067 1068 if (symbols) 1069 { 1070 if (! srec_write_symbols (abfd)) 1071 return FALSE; 1072 } 1073 1074 if (! srec_write_header (abfd)) 1075 return FALSE; 1076 1077 /* Now wander though all the sections provided and output them. */ 1078 list = tdata->head; 1079 1080 while (list != (srec_data_list_type *) NULL) 1081 { 1082 if (! srec_write_section (abfd, tdata, list)) 1083 return FALSE; 1084 list = list->next; 1085 } 1086 return srec_write_terminator (abfd, tdata); 1087} 1088 1089static bfd_boolean 1090srec_write_object_contents (bfd *abfd) 1091{ 1092 return internal_srec_write_object_contents (abfd, 0); 1093} 1094 1095static bfd_boolean 1096symbolsrec_write_object_contents (bfd *abfd) 1097{ 1098 return internal_srec_write_object_contents (abfd, 1); 1099} 1100 1101static int 1102srec_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED, 1103 struct bfd_link_info *info ATTRIBUTE_UNUSED) 1104{ 1105 return 0; 1106} 1107 1108/* Return the amount of memory needed to read the symbol table. */ 1109 1110static long 1111srec_get_symtab_upper_bound (bfd *abfd) 1112{ 1113 return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *); 1114} 1115 1116/* Return the symbol table. */ 1117 1118static long 1119srec_canonicalize_symtab (bfd *abfd, asymbol **alocation) 1120{ 1121 bfd_size_type symcount = bfd_get_symcount (abfd); 1122 asymbol *csymbols; 1123 unsigned int i; 1124 1125 csymbols = abfd->tdata.srec_data->csymbols; 1126 if (csymbols == NULL) 1127 { 1128 asymbol *c; 1129 struct srec_symbol *s; 1130 1131 csymbols = bfd_alloc (abfd, symcount * sizeof (asymbol)); 1132 if (csymbols == NULL && symcount != 0) 1133 return 0; 1134 abfd->tdata.srec_data->csymbols = csymbols; 1135 1136 for (s = abfd->tdata.srec_data->symbols, c = csymbols; 1137 s != NULL; 1138 s = s->next, ++c) 1139 { 1140 c->the_bfd = abfd; 1141 c->name = s->name; 1142 c->value = s->val; 1143 c->flags = BSF_GLOBAL; 1144 c->section = bfd_abs_section_ptr; 1145 c->udata.p = NULL; 1146 } 1147 } 1148 1149 for (i = 0; i < symcount; i++) 1150 *alocation++ = csymbols++; 1151 *alocation = NULL; 1152 1153 return symcount; 1154} 1155 1156static void 1157srec_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED, 1158 asymbol *symbol, 1159 symbol_info *ret) 1160{ 1161 bfd_symbol_info (symbol, ret); 1162} 1163 1164static void 1165srec_print_symbol (bfd *abfd, 1166 void * afile, 1167 asymbol *symbol, 1168 bfd_print_symbol_type how) 1169{ 1170 FILE *file = (FILE *) afile; 1171 1172 switch (how) 1173 { 1174 case bfd_print_symbol_name: 1175 fprintf (file, "%s", symbol->name); 1176 break; 1177 default: 1178 bfd_print_symbol_vandf (abfd, (void *) file, symbol); 1179 fprintf (file, " %-5s %s", 1180 symbol->section->name, 1181 symbol->name); 1182 } 1183} 1184 1185#define srec_close_and_cleanup _bfd_generic_close_and_cleanup 1186#define srec_bfd_free_cached_info _bfd_generic_bfd_free_cached_info 1187#define srec_new_section_hook _bfd_generic_new_section_hook 1188#define srec_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false) 1189#define srec_bfd_is_local_label_name bfd_generic_is_local_label_name 1190#define srec_get_lineno _bfd_nosymbols_get_lineno 1191#define srec_find_nearest_line _bfd_nosymbols_find_nearest_line 1192#define srec_find_inliner_info _bfd_nosymbols_find_inliner_info 1193#define srec_make_empty_symbol _bfd_generic_make_empty_symbol 1194#define srec_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol 1195#define srec_read_minisymbols _bfd_generic_read_minisymbols 1196#define srec_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol 1197#define srec_get_section_contents_in_window _bfd_generic_get_section_contents_in_window 1198#define srec_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents 1199#define srec_bfd_relax_section bfd_generic_relax_section 1200#define srec_bfd_gc_sections bfd_generic_gc_sections 1201#define srec_bfd_merge_sections bfd_generic_merge_sections 1202#define srec_bfd_is_group_section bfd_generic_is_group_section 1203#define srec_bfd_discard_group bfd_generic_discard_group 1204#define srec_section_already_linked _bfd_generic_section_already_linked 1205#define srec_bfd_link_hash_table_create _bfd_generic_link_hash_table_create 1206#define srec_bfd_link_hash_table_free _bfd_generic_link_hash_table_free 1207#define srec_bfd_link_add_symbols _bfd_generic_link_add_symbols 1208#define srec_bfd_link_just_syms _bfd_generic_link_just_syms 1209#define srec_bfd_final_link _bfd_generic_final_link 1210#define srec_bfd_link_split_section _bfd_generic_link_split_section 1211 1212const bfd_target srec_vec = 1213{ 1214 "srec", /* Name. */ 1215 bfd_target_srec_flavour, 1216 BFD_ENDIAN_UNKNOWN, /* Target byte order. */ 1217 BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */ 1218 (HAS_RELOC | EXEC_P | /* Object flags. */ 1219 HAS_LINENO | HAS_DEBUG | 1220 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED), 1221 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS 1222 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */ 1223 0, /* Leading underscore. */ 1224 ' ', /* AR_pad_char. */ 1225 16, /* AR_max_namelen. */ 1226 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1227 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1228 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */ 1229 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1230 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1231 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Hdrs. */ 1232 1233 { 1234 _bfd_dummy_target, 1235 srec_object_p, /* bfd_check_format. */ 1236 _bfd_dummy_target, 1237 _bfd_dummy_target, 1238 }, 1239 { 1240 bfd_false, 1241 srec_mkobject, 1242 _bfd_generic_mkarchive, 1243 bfd_false, 1244 }, 1245 { /* bfd_write_contents. */ 1246 bfd_false, 1247 srec_write_object_contents, 1248 _bfd_write_archive_contents, 1249 bfd_false, 1250 }, 1251 1252 BFD_JUMP_TABLE_GENERIC (srec), 1253 BFD_JUMP_TABLE_COPY (_bfd_generic), 1254 BFD_JUMP_TABLE_CORE (_bfd_nocore), 1255 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), 1256 BFD_JUMP_TABLE_SYMBOLS (srec), 1257 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), 1258 BFD_JUMP_TABLE_WRITE (srec), 1259 BFD_JUMP_TABLE_LINK (srec), 1260 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 1261 1262 NULL, 1263 1264 NULL 1265}; 1266 1267const bfd_target symbolsrec_vec = 1268{ 1269 "symbolsrec", /* Name. */ 1270 bfd_target_srec_flavour, 1271 BFD_ENDIAN_UNKNOWN, /* Target byte order. */ 1272 BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */ 1273 (HAS_RELOC | EXEC_P | /* Object flags. */ 1274 HAS_LINENO | HAS_DEBUG | 1275 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED), 1276 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS 1277 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */ 1278 0, /* Leading underscore. */ 1279 ' ', /* AR_pad_char. */ 1280 16, /* AR_max_namelen. */ 1281 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1282 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1283 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */ 1284 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1285 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1286 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */ 1287 1288 { 1289 _bfd_dummy_target, 1290 symbolsrec_object_p, /* bfd_check_format. */ 1291 _bfd_dummy_target, 1292 _bfd_dummy_target, 1293 }, 1294 { 1295 bfd_false, 1296 srec_mkobject, 1297 _bfd_generic_mkarchive, 1298 bfd_false, 1299 }, 1300 { /* bfd_write_contents. */ 1301 bfd_false, 1302 symbolsrec_write_object_contents, 1303 _bfd_write_archive_contents, 1304 bfd_false, 1305 }, 1306 1307 BFD_JUMP_TABLE_GENERIC (srec), 1308 BFD_JUMP_TABLE_COPY (_bfd_generic), 1309 BFD_JUMP_TABLE_CORE (_bfd_nocore), 1310 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), 1311 BFD_JUMP_TABLE_SYMBOLS (srec), 1312 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), 1313 BFD_JUMP_TABLE_WRITE (srec), 1314 BFD_JUMP_TABLE_LINK (srec), 1315 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 1316 1317 NULL, 1318 1319 NULL 1320}; 1321