bfd/srec.c

   1 /* BFD back-end for s-record objects.
   2    Copyright (C) 1990-2024 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 _bfd_srec_len = 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 bool _bfd_srec_forceS3 = 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 bool 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 bool
 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, bool *errorptr)
 219 {
 220   bfd_byte c;
 221
 222   if (bfd_read (&c, 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                bool 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         /* xgettext:c-format */
 260         (_("%pB:%d: unexpected character `%s' in S-record file"),
 261          abfd, lineno, buf);
 262       bfd_set_error (bfd_error_bad_value);
 263     }
 264 }
 265
 266 /* Add a new symbol found in an S-record file.  */
 267
 268 static bool
 269 srec_new_symbol (bfd *abfd, const char *name, bfd_vma val)
 270 {
 271   struct srec_symbol *n;
 272
 273   n = (struct srec_symbol *) bfd_alloc (abfd, sizeof (* n));
 274   if (n == NULL)
 275     return false;
 276
 277   n->name = name;
 278   n->val = val;
 279
 280   if (abfd->tdata.srec_data->symbols == NULL)
 281     abfd->tdata.srec_data->symbols = n;
 282   else
 283     abfd->tdata.srec_data->symtail->next = n;
 284   abfd->tdata.srec_data->symtail = n;
 285   n->next = NULL;
 286
 287   ++abfd->symcount;
 288
 289   return true;
 290 }
 291
 292 /* Read the S record file and turn it into sections.  We create a new
 293    section for each contiguous set of bytes.  */
 294
 295 static bool
 296 srec_scan (bfd *abfd)
 297 {
 298   int c;
 299   unsigned int lineno = 1;
 300   bool error = false;
 301   bfd_byte *buf = NULL;
 302   size_t bufsize = 0;
 303   asection *sec = NULL;
 304   char *symbuf = NULL;
 305
 306   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 307     goto error_return;
 308
 309   while ((c = srec_get_byte (abfd, &error)) != EOF)
 310     {
 311       /* We only build sections from contiguous S-records, so if this
 312          is not an S-record, then stop building a section.  */
 313       if (c != 'S' && c != '\r' && c != '\n')
 314         sec = NULL;
 315
 316       switch (c)
 317         {
 318         default:
 319           srec_bad_byte (abfd, lineno, c, error);
 320           goto error_return;
 321
 322         case '\n':
 323           ++lineno;
 324           break;
 325
 326         case '\r':
 327           break;
 328
 329         case '$':
 330           /* Starting a module name, which we ignore.  */
 331           while ((c = srec_get_byte (abfd, &error)) != '\n'
 332                  && c != EOF)
 333             ;
 334           if (c == EOF)
 335             {
 336               srec_bad_byte (abfd, lineno, c, error);
 337               goto error_return;
 338             }
 339
 340           ++lineno;
 341           break;
 342
 343         case ' ':
 344           do
 345             {
 346               bfd_size_type alc;
 347               char *p, *symname;
 348               bfd_vma symval;
 349
 350               /* Starting a symbol definition.  */
 351               while ((c = srec_get_byte (abfd, &error)) != EOF
 352                      && (c == ' ' || c == '\t'))
 353                 ;
 354
 355               if (c == '\n' || c == '\r')
 356                 break;
 357
 358               if (c == EOF)
 359                 {
 360                   srec_bad_byte (abfd, lineno, c, error);
 361                   goto error_return;
 362                 }
 363
 364               alc = 10;
 365               symbuf = (char *) bfd_malloc (alc + 1);
 366               if (symbuf == NULL)
 367                 goto error_return;
 368
 369               p = symbuf;
 370
 371               *p++ = c;
 372               while ((c = srec_get_byte (abfd, &error)) != EOF
 373                      && ! ISSPACE (c))
 374                 {
 375                   if ((bfd_size_type) (p - symbuf) >= alc)
 376                     {
 377                       char *n;
 378
 379                       alc *= 2;
 380                       n = (char *) bfd_realloc (symbuf, alc + 1);
 381                       if (n == NULL)
 382                         goto error_return;
 383                       p = n + (p - symbuf);
 384                       symbuf = n;
 385                     }
 386
 387                   *p++ = c;
 388                 }
 389
 390               if (c == EOF)
 391                 {
 392                   srec_bad_byte (abfd, lineno, c, error);
 393                   goto error_return;
 394                 }
 395
 396               *p++ = '\0';
 397               symname = (char *) bfd_alloc (abfd, (bfd_size_type) (p - symbuf));
 398               if (symname == NULL)
 399                 goto error_return;
 400               strcpy (symname, symbuf);
 401               free (symbuf);
 402               symbuf = NULL;
 403
 404               while ((c = srec_get_byte (abfd, &error)) != EOF
 405                      && (c == ' ' || c == '\t'))
 406                 ;
 407               if (c == EOF)
 408                 {
 409                   srec_bad_byte (abfd, lineno, c, error);
 410                   goto error_return;
 411                 }
 412
 413               /* Skip a dollar sign before the hex value.  */
 414               if (c == '$')
 415                 {
 416                   c = srec_get_byte (abfd, &error);
 417                   if (c == EOF)
 418                     {
 419                       srec_bad_byte (abfd, lineno, c, error);
 420                       goto error_return;
 421                     }
 422                 }
 423
 424               symval = 0;
 425               while (ISHEX (c))
 426                 {
 427                   symval <<= 4;
 428                   symval += NIBBLE (c);
 429                   c = srec_get_byte (abfd, &error);
 430                   if (c == EOF)
 431                     {
 432                       srec_bad_byte (abfd, lineno, c, error);
 433                       goto error_return;
 434                     }
 435                 }
 436
 437               if (! srec_new_symbol (abfd, symname, symval))
 438                 goto error_return;
 439             }
 440           while (c == ' ' || c == '\t')
 441             ;
 442
 443           if (c == '\n')
 444             ++lineno;
 445           else if (c != '\r')
 446             {
 447               srec_bad_byte (abfd, lineno, c, error);
 448               goto error_return;
 449             }
 450
 451           break;
 452
 453         case 'S':
 454           {
 455             file_ptr pos;
 456             unsigned char hdr[3];
 457             unsigned int bytes, min_bytes;
 458             bfd_vma address;
 459             bfd_byte *data;
 460             unsigned char check_sum;
 461
 462             /* Starting an S-record.  */
 463
 464             pos = bfd_tell (abfd) - 1;
 465
 466             if (bfd_read (hdr, 3, abfd) != 3)
 467               goto error_return;
 468
 469             if (! ISHEX (hdr[1]) || ! ISHEX (hdr[2]))
 470               {
 471                 if (! ISHEX (hdr[1]))
 472                   c = hdr[1];
 473                 else
 474                   c = hdr[2];
 475                 srec_bad_byte (abfd, lineno, c, error);
 476                 goto error_return;
 477               }
 478
 479             check_sum = bytes = HEX (hdr + 1);
 480             min_bytes = 3;
 481             if (hdr[0] == '2' || hdr[0] == '8')
 482               min_bytes = 4;
 483             else if (hdr[0] == '3' || hdr[0] == '7')
 484               min_bytes = 5;
 485             if (bytes < min_bytes)
 486               {
 487                 /* xgettext:c-format */
 488                 _bfd_error_handler (_("%pB:%d: byte count %d too small"),
 489                                     abfd, lineno, bytes);
 490                 bfd_set_error (bfd_error_bad_value);
 491                 goto error_return;
 492               }
 493
 494             if (bytes * 2 > bufsize)
 495               {
 496                 free (buf);
 497                 buf = bfd_malloc (bytes * 2);
 498                 if (buf == NULL)
 499                   goto error_return;
 500                 bufsize = bytes * 2;
 501               }
 502
 503             if (bfd_read (buf, bytes * 2, abfd) != bytes * 2)
 504               goto error_return;
 505
 506             /* Ignore the checksum byte.  */
 507             --bytes;
 508
 509             address = 0;
 510             data = buf;
 511             switch (hdr[0])
 512               {
 513               case '0':
 514               case '5':
 515                 /* Prologue--ignore the file name, but stop building a
 516                    section at this point.  */
 517                 sec = NULL;
 518                 break;
 519
 520               case '3':
 521                 check_sum += HEX (data);
 522                 address = HEX (data);
 523                 data += 2;
 524                 --bytes;
 525                 /* Fall through.  */
 526               case '2':
 527                 check_sum += HEX (data);
 528                 address = (address << 8) | HEX (data);
 529                 data += 2;
 530                 --bytes;
 531                 /* Fall through.  */
 532               case '1':
 533                 check_sum += HEX (data);
 534                 address = (address << 8) | HEX (data);
 535                 data += 2;
 536                 check_sum += HEX (data);
 537                 address = (address << 8) | HEX (data);
 538                 data += 2;
 539                 bytes -= 2;
 540
 541                 if (sec != NULL
 542                     && sec->vma + sec->size == address)
 543                   {
 544                     /* This data goes at the end of the section we are
 545                        currently building.  */
 546                     sec->size += bytes;
 547                   }
 548                 else
 549                   {
 550                     char secbuf[20];
 551                     char *secname;
 552                     size_t amt;
 553                     flagword flags;
 554
 555                     sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
 556                     amt = strlen (secbuf) + 1;
 557                     secname = (char *) bfd_alloc (abfd, amt);
 558                     strcpy (secname, secbuf);
 559                     flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
 560                     sec = bfd_make_section_with_flags (abfd, secname, flags);
 561                     if (sec == NULL)
 562                       goto error_return;
 563                     sec->vma = address;
 564                     sec->lma = address;
 565                     sec->size = bytes;
 566                     sec->filepos = pos;
 567                   }
 568
 569                 while (bytes > 0)
 570                   {
 571                     check_sum += HEX (data);
 572                     data += 2;
 573                     bytes--;
 574                   }
 575                 check_sum = 255 - (check_sum & 0xff);
 576                 if (check_sum != HEX (data))
 577                   {
 578                     _bfd_error_handler
 579                       /* xgettext:c-format */
 580                       (_("%pB:%d: bad checksum in S-record file"),
 581                        abfd, lineno);
 582                     bfd_set_error (bfd_error_bad_value);
 583                     goto error_return;
 584                   }
 585
 586                 break;
 587
 588               case '7':
 589                 check_sum += HEX (data);
 590                 address = HEX (data);
 591                 data += 2;
 592                 /* Fall through.  */
 593               case '8':
 594                 check_sum += HEX (data);
 595                 address = (address << 8) | HEX (data);
 596                 data += 2;
 597                 /* Fall through.  */
 598               case '9':
 599                 check_sum += HEX (data);
 600                 address = (address << 8) | HEX (data);
 601                 data += 2;
 602                 check_sum += HEX (data);
 603                 address = (address << 8) | HEX (data);
 604                 data += 2;
 605
 606                 /* This is a termination record.  */
 607                 abfd->start_address = address;
 608
 609                 check_sum = 255 - (check_sum & 0xff);
 610                 if (check_sum != HEX (data))
 611                   {
 612                     _bfd_error_handler
 613                       /* xgettext:c-format */
 614                       (_("%pB:%d: bad checksum in S-record file"),
 615                        abfd, lineno);
 616                     bfd_set_error (bfd_error_bad_value);
 617                     goto error_return;
 618                   }
 619
 620                 free (buf);
 621                 return true;
 622               }
 623           }
 624           break;
 625         }
 626     }
 627
 628   if (error)
 629     goto error_return;
 630
 631   free (buf);
 632   return true;
 633
 634  error_return:
 635   free (symbuf);
 636   free (buf);
 637   return false;
 638 }
 639
 640 /* Check whether an existing file is an S-record file.  */
 641
 642 static bfd_cleanup
 643 srec_object_p (bfd *abfd)
 644 {
 645   bfd_byte b[4];
 646
 647   srec_init ();
 648
 649   if (bfd_seek (abfd, 0, SEEK_SET) != 0
 650       || bfd_read (b, 4, abfd) != 4)
 651     return NULL;
 652
 653   if (b[0] != 'S' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
 654     {
 655       bfd_set_error (bfd_error_wrong_format);
 656       return NULL;
 657     }
 658
 659   if (!srec_mkobject (abfd))
 660     return NULL;
 661
 662   if (!srec_scan (abfd))
 663     {
 664       bfd_release (abfd, abfd->tdata.any);
 665       return NULL;
 666     }
 667
 668   if (abfd->symcount > 0)
 669     abfd->flags |= HAS_SYMS;
 670
 671   return _bfd_no_cleanup;
 672 }
 673
 674 /* Check whether an existing file is an S-record file with symbols.  */
 675
 676 static bfd_cleanup
 677 symbolsrec_object_p (bfd *abfd)
 678 {
 679   char b[2];
 680
 681   srec_init ();
 682
 683   if (bfd_seek (abfd, 0, SEEK_SET) != 0
 684       || bfd_read (b, 2, abfd) != 2)
 685     return NULL;
 686
 687   if (b[0] != '$' || b[1] != '$')
 688     {
 689       bfd_set_error (bfd_error_wrong_format);
 690       return NULL;
 691     }
 692
 693   if (!srec_mkobject (abfd))
 694     return NULL;
 695
 696   if (!srec_scan (abfd))
 697     {
 698       bfd_release (abfd, abfd->tdata.any);
 699       return NULL;
 700     }
 701
 702   if (abfd->symcount > 0)
 703     abfd->flags |= HAS_SYMS;
 704
 705   return _bfd_no_cleanup;
 706 }
 707
 708 /* Read in the contents of a section in an S-record file.  */
 709
 710 static bool
 711 srec_read_section (bfd *abfd, asection *section, bfd_byte *contents)
 712 {
 713   int c;
 714   bfd_size_type sofar = 0;
 715   bool error = false;
 716   bfd_byte *buf = NULL;
 717   size_t bufsize = 0;
 718
 719   if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
 720     goto error_return;
 721
 722   while ((c = srec_get_byte (abfd, &error)) != EOF)
 723     {
 724       bfd_byte hdr[3];
 725       unsigned int bytes;
 726       bfd_vma address;
 727       bfd_byte *data;
 728
 729       if (c == '\r' || c == '\n')
 730         continue;
 731
 732       /* This is called after srec_scan has already been called, so we
 733          ought to know the exact format.  */
 734       if (c != 'S')
 735         goto error_return;
 736
 737       if (bfd_read (hdr, 3, abfd) != 3)
 738         goto error_return;
 739
 740       BFD_ASSERT (ISHEX (hdr[1]) && ISHEX (hdr[2]));
 741
 742       bytes = HEX (hdr + 1);
 743
 744       if (bytes * 2 > bufsize)
 745         {
 746           free (buf);
 747           buf = bfd_malloc (bytes * 2);
 748           if (buf == NULL)
 749             goto error_return;
 750           bufsize = bytes * 2;
 751         }
 752
 753       if (bfd_read (buf, bytes * 2, abfd) != bytes * 2)
 754         goto error_return;
 755
 756       address = 0;
 757       data = buf;
 758       switch (hdr[0])
 759         {
 760         default:
 761           if (sofar != section->size)
 762             goto error_return;
 763           free (buf);
 764           return true;
 765
 766         case '3':
 767           address = HEX (data);
 768           data += 2;
 769           --bytes;
 770           /* Fall through.  */
 771         case '2':
 772           address = (address << 8) | HEX (data);
 773           data += 2;
 774           --bytes;
 775           /* Fall through.  */
 776         case '1':
 777           address = (address << 8) | HEX (data);
 778           data += 2;
 779           address = (address << 8) | HEX (data);
 780           data += 2;
 781           bytes -= 2;
 782
 783           if (address != section->vma + sofar)
 784             {
 785               /* We've come to the end of this section.  */
 786               if (sofar != section->size)
 787                 goto error_return;
 788               free (buf);
 789               return true;
 790             }
 791
 792           /* Don't consider checksum.  */
 793           --bytes;
 794
 795           while (bytes-- != 0)
 796             {
 797               contents[sofar] = HEX (data);
 798               data += 2;
 799               ++sofar;
 800             }
 801
 802           break;
 803         }
 804     }
 805
 806   if (error)
 807     goto error_return;
 808
 809   if (sofar != section->size)
 810     goto error_return;
 811
 812   free (buf);
 813   return true;
 814
 815  error_return:
 816   free (buf);
 817   return false;
 818 }
 819
 820 /* Get the contents of a section in an S-record file.  */
 821
 822 static bool
 823 srec_get_section_contents (bfd *abfd,
 824                            asection *section,
 825                            void * location,
 826                            file_ptr offset,
 827                            bfd_size_type count)
 828 {
 829   if (count == 0)
 830     return true;
 831
 832   if (offset + count < count
 833       || offset + count > section->size)
 834     {
 835       bfd_set_error (bfd_error_invalid_operation);
 836       return false;
 837     }
 838
 839   if (section->used_by_bfd == NULL)
 840     {
 841       section->used_by_bfd = bfd_alloc (abfd, section->size);
 842       if (section->used_by_bfd == NULL)
 843         return false;
 844
 845       if (! srec_read_section (abfd, section,
 846                                (bfd_byte *) section->used_by_bfd))
 847         return false;
 848     }
 849
 850   memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
 851           (size_t) count);
 852
 853   return true;
 854 }
 855
 856 /* Set the architecture.  We accept an unknown architecture here.  */
 857
 858 static bool
 859 srec_set_arch_mach (bfd *abfd, enum bfd_architecture arch, unsigned long mach)
 860 {
 861   if (arch != bfd_arch_unknown)
 862     return bfd_default_set_arch_mach (abfd, arch, mach);
 863
 864   abfd->arch_info = & bfd_default_arch_struct;
 865   return true;
 866 }
 867
 868 /* We have to save up all the Srecords for a splurge before output.  */
 869
 870 static bool
 871 srec_set_section_contents (bfd *abfd,
 872                            sec_ptr section,
 873                            const void * location,
 874                            file_ptr offset,
 875                            bfd_size_type bytes_to_do)
 876 {
 877   int opb = bfd_octets_per_byte (abfd, NULL);
 878   tdata_type *tdata = abfd->tdata.srec_data;
 879   srec_data_list_type *entry;
 880
 881   entry = (srec_data_list_type *) bfd_alloc (abfd, sizeof (* entry));
 882   if (entry == NULL)
 883     return false;
 884
 885   if (bytes_to_do
 886       && (section->flags & SEC_ALLOC)
 887       && (section->flags & SEC_LOAD))
 888     {
 889       bfd_byte *data;
 890
 891       data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do);
 892       if (data == NULL)
 893         return false;
 894       memcpy ((void *) data, location, (size_t) bytes_to_do);
 895
 896       /* If _bfd_srec_forceS3 is TRUE then always select S3 records,
 897          regardless of the size of the addresses.  */
 898       if (_bfd_srec_forceS3)
 899         tdata->type = 3;
 900       else if ((section->lma + (offset + bytes_to_do) / opb - 1) <= 0xffff)
 901         ;  /* The default, S1, is OK.  */
 902       else if ((section->lma + (offset + bytes_to_do) / opb - 1) <= 0xffffff
 903                && tdata->type <= 2)
 904         tdata->type = 2;
 905       else
 906         tdata->type = 3;
 907
 908       entry->data = data;
 909       entry->where = section->lma + offset / opb;
 910       entry->size = bytes_to_do;
 911
 912       /* Sort the records by address.  Optimize for the common case of
 913          adding a record to the end of the list.  */
 914       if (tdata->tail != NULL
 915           && entry->where >= tdata->tail->where)
 916         {
 917           tdata->tail->next = entry;
 918           entry->next = NULL;
 919           tdata->tail = entry;
 920         }
 921       else
 922         {
 923           srec_data_list_type **look;
 924
 925           for (look = &tdata->head;
 926                *look != NULL && (*look)->where < entry->where;
 927                look = &(*look)->next)
 928             ;
 929           entry->next = *look;
 930           *look = entry;
 931           if (entry->next == NULL)
 932             tdata->tail = entry;
 933         }
 934     }
 935   return true;
 936 }
 937
 938 /* Write a record of type, of the supplied number of bytes. The
 939    supplied bytes and length don't have a checksum. That's worked out
 940    here.  */
 941
 942 static bool
 943 srec_write_record (bfd *abfd,
 944                    unsigned int type,
 945                    bfd_vma address,
 946                    const bfd_byte *data,
 947                    const bfd_byte *end)
 948 {
 949   char buffer[2 * MAXCHUNK + 6];
 950   unsigned int check_sum = 0;
 951   const bfd_byte *src = data;
 952   char *dst = buffer;
 953   char *length;
 954   bfd_size_type wrlen;
 955
 956   *dst++ = 'S';
 957   *dst++ = '0' + type;
 958
 959   length = dst;
 960   dst += 2;                     /* Leave room for dst.  */
 961
 962   switch (type)
 963     {
 964     case 3:
 965     case 7:
 966       TOHEX (dst, (address >> 24), check_sum);
 967       dst += 2;
 968       /* Fall through.  */
 969     case 8:
 970     case 2:
 971       TOHEX (dst, (address >> 16), check_sum);
 972       dst += 2;
 973       /* Fall through.  */
 974     case 9:
 975     case 1:
 976     case 0:
 977       TOHEX (dst, (address >> 8), check_sum);
 978       dst += 2;
 979       TOHEX (dst, (address), check_sum);
 980       dst += 2;
 981       break;
 982
 983     }
 984   for (src = data; src < end; src++)
 985     {
 986       TOHEX (dst, *src, check_sum);
 987       dst += 2;
 988     }
 989
 990   /* Fill in the length.  */
 991   TOHEX (length, (dst - length) / 2, check_sum);
 992   check_sum &= 0xff;
 993   check_sum = 255 - check_sum;
 994   TOHEX (dst, check_sum, check_sum);
 995   dst += 2;
 996
 997   *dst++ = '\r';
 998   *dst++ = '\n';
 999   wrlen = dst - buffer;
1000
1001   return bfd_write (buffer, wrlen, abfd) == wrlen;
1002 }
1003
1004 static bool
1005 srec_write_header (bfd *abfd)
1006 {
1007   unsigned int len = strlen (bfd_get_filename (abfd));
1008
1009   /* I'll put an arbitrary 40 char limit on header size.  */
1010   if (len > 40)
1011     len = 40;
1012
1013   return srec_write_record (abfd, 0, (bfd_vma) 0,
1014                             (bfd_byte *) bfd_get_filename (abfd),
1015                             (bfd_byte *) bfd_get_filename (abfd) + len);
1016 }
1017
1018 static bool
1019 srec_write_section (bfd *abfd,
1020                     tdata_type *tdata,
1021                     srec_data_list_type *list)
1022 {
1023   unsigned int octets_written = 0;
1024   bfd_byte *location = list->data;
1025
1026   /* Validate number of data bytes to write.  The srec length byte
1027      counts the address, data and crc bytes.  S1 (tdata->type == 1)
1028      records have two address bytes, S2 (tdata->type == 2) records
1029      have three, and S3 (tdata->type == 3) records have four.
1030      The total length can't exceed 255, and a zero data length will
1031      spin for a long time.  */
1032   if (_bfd_srec_len == 0)
1033     _bfd_srec_len = 1;
1034   else if (_bfd_srec_len > MAXCHUNK - tdata->type - 2)
1035     _bfd_srec_len = MAXCHUNK - tdata->type - 2;
1036
1037   while (octets_written < list->size)
1038     {
1039       bfd_vma address;
1040       unsigned int octets_this_chunk = list->size - octets_written;
1041
1042       if (octets_this_chunk > _bfd_srec_len)
1043         octets_this_chunk = _bfd_srec_len;
1044
1045       address = list->where + (octets_written
1046                                / bfd_octets_per_byte (abfd, NULL));
1047
1048       if (! srec_write_record (abfd,
1049                                tdata->type,
1050                                address,
1051                                location,
1052                                location + octets_this_chunk))
1053         return false;
1054
1055       octets_written += octets_this_chunk;
1056       location += octets_this_chunk;
1057     }
1058
1059   return true;
1060 }
1061
1062 static bool
1063 srec_write_terminator (bfd *abfd, tdata_type *tdata)
1064 {
1065   return srec_write_record (abfd, 10 - tdata->type,
1066                             abfd->start_address, NULL, NULL);
1067 }
1068
1069 static bool
1070 srec_write_symbols (bfd *abfd)
1071 {
1072   /* Dump out the symbols of a bfd.  */
1073   int i;
1074   int count = bfd_get_symcount (abfd);
1075
1076   if (count)
1077     {
1078       bfd_size_type len;
1079       asymbol **table = bfd_get_outsymbols (abfd);
1080
1081       len = strlen (bfd_get_filename (abfd));
1082       if (bfd_write ("$$ ", 3, abfd) != 3
1083           || bfd_write (bfd_get_filename (abfd), len, abfd) != len
1084           || bfd_write ("\r\n", 2, abfd) != 2)
1085         return false;
1086
1087       for (i = 0; i < count; i++)
1088         {
1089           asymbol *s = table[i];
1090
1091           if (! bfd_is_local_label (abfd, s)
1092               && (s->flags & BSF_DEBUGGING) == 0
1093               && s->section != NULL
1094               && s->section->output_section != NULL)
1095             {
1096               /* Just dump out non debug symbols.  */
1097               char buf[43];
1098
1099               len = strlen (s->name);
1100               if (bfd_write ("  ", 2, abfd) != 2
1101                   || bfd_write (s->name, len, abfd) != len)
1102                 return false;
1103
1104               sprintf (buf, " $%" PRIx64 "\r\n",
1105                        (uint64_t) (s->value
1106                                    + s->section->output_section->lma
1107                                    + s->section->output_offset));
1108               len = strlen (buf);
1109               if (bfd_write (buf, len, abfd) != len)
1110                 return false;
1111             }
1112         }
1113       if (bfd_write ("$$ \r\n", 5, abfd) != 5)
1114         return false;
1115     }
1116
1117   return true;
1118 }
1119
1120 static bool
1121 internal_srec_write_object_contents (bfd *abfd, int symbols)
1122 {
1123   tdata_type *tdata = abfd->tdata.srec_data;
1124   srec_data_list_type *list;
1125
1126   if (symbols)
1127     {
1128       if (! srec_write_symbols (abfd))
1129         return false;
1130     }
1131
1132   if (! srec_write_header (abfd))
1133     return false;
1134
1135   /* Now wander though all the sections provided and output them.  */
1136   list = tdata->head;
1137
1138   while (list != (srec_data_list_type *) NULL)
1139     {
1140       if (! srec_write_section (abfd, tdata, list))
1141         return false;
1142       list = list->next;
1143     }
1144   return srec_write_terminator (abfd, tdata);
1145 }
1146
1147 static bool
1148 srec_write_object_contents (bfd *abfd)
1149 {
1150   return internal_srec_write_object_contents (abfd, 0);
1151 }
1152
1153 static bool
1154 symbolsrec_write_object_contents (bfd *abfd)
1155 {
1156   return internal_srec_write_object_contents (abfd, 1);
1157 }
1158
1159 static int
1160 srec_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
1161                      struct bfd_link_info *info ATTRIBUTE_UNUSED)
1162 {
1163   return 0;
1164 }
1165
1166 /* Return the amount of memory needed to read the symbol table.  */
1167
1168 static long
1169 srec_get_symtab_upper_bound (bfd *abfd)
1170 {
1171   return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *);
1172 }
1173
1174 /* Return the symbol table.  */
1175
1176 static long
1177 srec_canonicalize_symtab (bfd *abfd, asymbol **alocation)
1178 {
1179   bfd_size_type symcount = bfd_get_symcount (abfd);
1180   asymbol *csymbols;
1181   unsigned int i;
1182
1183   csymbols = abfd->tdata.srec_data->csymbols;
1184   if (csymbols == NULL && symcount != 0)
1185     {
1186       asymbol *c;
1187       struct srec_symbol *s;
1188
1189       csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));
1190       if (csymbols == NULL)
1191         return -1;
1192       abfd->tdata.srec_data->csymbols = csymbols;
1193
1194       for (s = abfd->tdata.srec_data->symbols, c = csymbols;
1195            s != NULL;
1196            s = s->next, ++c)
1197         {
1198           c->the_bfd = abfd;
1199           c->name = s->name;
1200           c->value = s->val;
1201           c->flags = BSF_GLOBAL;
1202           c->section = bfd_abs_section_ptr;
1203           c->udata.p = NULL;
1204         }
1205     }
1206
1207   for (i = 0; i < symcount; i++)
1208     *alocation++ = csymbols++;
1209   *alocation = NULL;
1210
1211   return symcount;
1212 }
1213
1214 static void
1215 srec_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
1216                       asymbol *symbol,
1217                       symbol_info *ret)
1218 {
1219   bfd_symbol_info (symbol, ret);
1220 }
1221
1222 static void
1223 srec_print_symbol (bfd *abfd,
1224                    void * afile,
1225                    asymbol *symbol,
1226                    bfd_print_symbol_type how)
1227 {
1228   FILE *file = (FILE *) afile;
1229
1230   switch (how)
1231     {
1232     case bfd_print_symbol_name:
1233       fprintf (file, "%s", symbol->name);
1234       break;
1235     default:
1236       bfd_print_symbol_vandf (abfd, (void *) file, symbol);
1237       fprintf (file, " %-5s %s",
1238                symbol->section->name,
1239                symbol->name);
1240     }
1241 }
1242
1243 #define srec_close_and_cleanup                    _bfd_generic_close_and_cleanup
1244 #define srec_bfd_free_cached_info                 _bfd_generic_bfd_free_cached_info
1245 #define srec_new_section_hook                     _bfd_generic_new_section_hook
1246 #define srec_bfd_is_target_special_symbol         _bfd_bool_bfd_asymbol_false
1247 #define srec_bfd_is_local_label_name              bfd_generic_is_local_label_name
1248 #define srec_get_lineno                           _bfd_nosymbols_get_lineno
1249 #define srec_find_nearest_line                    _bfd_nosymbols_find_nearest_line
1250 #define srec_find_nearest_line_with_alt           _bfd_nosymbols_find_nearest_line_with_alt
1251 #define srec_find_line                            _bfd_nosymbols_find_line
1252 #define srec_find_inliner_info                    _bfd_nosymbols_find_inliner_info
1253 #define srec_make_empty_symbol                    _bfd_generic_make_empty_symbol
1254 #define srec_get_symbol_version_string            _bfd_nosymbols_get_symbol_version_string
1255 #define srec_bfd_make_debug_symbol                _bfd_nosymbols_bfd_make_debug_symbol
1256 #define srec_read_minisymbols                     _bfd_generic_read_minisymbols
1257 #define srec_minisymbol_to_symbol                 _bfd_generic_minisymbol_to_symbol
1258 #define srec_bfd_get_relocated_section_contents   bfd_generic_get_relocated_section_contents
1259 #define srec_bfd_relax_section                    bfd_generic_relax_section
1260 #define srec_bfd_gc_sections                      bfd_generic_gc_sections
1261 #define srec_bfd_lookup_section_flags             bfd_generic_lookup_section_flags
1262 #define srec_bfd_merge_sections                   bfd_generic_merge_sections
1263 #define srec_bfd_is_group_section                 bfd_generic_is_group_section
1264 #define srec_bfd_group_name                       bfd_generic_group_name
1265 #define srec_bfd_discard_group                    bfd_generic_discard_group
1266 #define srec_section_already_linked               _bfd_generic_section_already_linked
1267 #define srec_bfd_define_common_symbol             bfd_generic_define_common_symbol
1268 #define srec_bfd_link_hide_symbol                 _bfd_generic_link_hide_symbol
1269 #define srec_bfd_define_start_stop                bfd_generic_define_start_stop
1270 #define srec_bfd_link_hash_table_create           _bfd_generic_link_hash_table_create
1271 #define srec_bfd_link_add_symbols                 _bfd_generic_link_add_symbols
1272 #define srec_bfd_link_just_syms                   _bfd_generic_link_just_syms
1273 #define srec_bfd_copy_link_hash_symbol_type       _bfd_generic_copy_link_hash_symbol_type
1274 #define srec_bfd_final_link                       _bfd_generic_final_link
1275 #define srec_bfd_link_split_section               _bfd_generic_link_split_section
1276 #define srec_bfd_link_check_relocs                _bfd_generic_link_check_relocs
1277
1278 const bfd_target srec_vec =
1279 {
1280   "srec",                       /* Name.  */
1281   bfd_target_srec_flavour,
1282   BFD_ENDIAN_UNKNOWN,           /* Target byte order.  */
1283   BFD_ENDIAN_UNKNOWN,           /* Target headers byte order.  */
1284   (HAS_RELOC | EXEC_P |         /* Object flags.  */
1285    HAS_LINENO | HAS_DEBUG |
1286    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1287   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1288    | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags.  */
1289   0,                            /* Leading underscore.  */
1290   ' ',                          /* AR_pad_char.  */
1291   16,                           /* AR_max_namelen.  */
1292   0,                            /* match priority.  */
1293   TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols.  */
1294   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1295   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1296   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Data.  */
1297   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1298   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1299   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Hdrs.  */
1300
1301   {
1302     _bfd_dummy_target,
1303     srec_object_p,              /* bfd_check_format.  */
1304     _bfd_dummy_target,
1305     _bfd_dummy_target,
1306   },
1307   {
1308     _bfd_bool_bfd_false_error,
1309     srec_mkobject,
1310     _bfd_generic_mkarchive,
1311     _bfd_bool_bfd_false_error,
1312   },
1313   {                             /* bfd_write_contents.  */
1314     _bfd_bool_bfd_false_error,
1315     srec_write_object_contents,
1316     _bfd_write_archive_contents,
1317     _bfd_bool_bfd_false_error,
1318   },
1319
1320   BFD_JUMP_TABLE_GENERIC (srec),
1321   BFD_JUMP_TABLE_COPY (_bfd_generic),
1322   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1323   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1324   BFD_JUMP_TABLE_SYMBOLS (srec),
1325   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1326   BFD_JUMP_TABLE_WRITE (srec),
1327   BFD_JUMP_TABLE_LINK (srec),
1328   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1329
1330   NULL,
1331
1332   NULL
1333 };
1334
1335 const bfd_target symbolsrec_vec =
1336 {
1337   "symbolsrec",                 /* Name.  */
1338   bfd_target_srec_flavour,
1339   BFD_ENDIAN_UNKNOWN,           /* Target byte order.  */
1340   BFD_ENDIAN_UNKNOWN,           /* Target headers byte order.  */
1341   (HAS_RELOC | EXEC_P |         /* Object flags.  */
1342    HAS_LINENO | HAS_DEBUG |
1343    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1344   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1345    | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags.  */
1346   0,                            /* Leading underscore.  */
1347   ' ',                          /* AR_pad_char.  */
1348   16,                           /* AR_max_namelen.  */
1349   0,                            /* match priority.  */
1350   TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols.  */
1351   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1352   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1353   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Data.  */
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,   /* Headers.  */
1357
1358   {
1359     _bfd_dummy_target,
1360     symbolsrec_object_p,        /* bfd_check_format.  */
1361     _bfd_dummy_target,
1362     _bfd_dummy_target,
1363   },
1364   {
1365     _bfd_bool_bfd_false_error,
1366     srec_mkobject,
1367     _bfd_generic_mkarchive,
1368     _bfd_bool_bfd_false_error,
1369   },
1370   {                             /* bfd_write_contents.  */
1371     _bfd_bool_bfd_false_error,
1372     symbolsrec_write_object_contents,
1373     _bfd_write_archive_contents,
1374     _bfd_bool_bfd_false_error,
1375   },
1376
1377   BFD_JUMP_TABLE_GENERIC (srec),
1378   BFD_JUMP_TABLE_COPY (_bfd_generic),
1379   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1380   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1381   BFD_JUMP_TABLE_SYMBOLS (srec),
1382   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1383   BFD_JUMP_TABLE_WRITE (srec),
1384   BFD_JUMP_TABLE_LINK (srec),
1385   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1386
1387   NULL,
1388
1389   NULL
1390 };