bfd/srec.c

   1 /* BFD back-end for s-record objects.
   2    Copyright (C) 1990-2020 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 bfd_boolean _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 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         /* 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 bfd_boolean
 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 bfd_boolean
 296 srec_scan (bfd *abfd)
 297 {
 298   int c;
 299   unsigned int lineno = 1;
 300   bfd_boolean 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, (file_ptr) 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_bread (hdr, (bfd_size_type) 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_byte *) bfd_malloc ((bfd_size_type) bytes * 2);
 498                 if (buf == NULL)
 499                   goto error_return;
 500                 bufsize = bytes * 2;
 501               }
 502
 503             if (bfd_bread (buf, (bfd_size_type) 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   void * tdata_save;
 646   bfd_byte b[4];
 647
 648   srec_init ();
 649
 650   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
 651       || bfd_bread (b, (bfd_size_type) 4, abfd) != 4)
 652     return NULL;
 653
 654   if (b[0] != 'S' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
 655     {
 656       bfd_set_error (bfd_error_wrong_format);
 657       return NULL;
 658     }
 659
 660   tdata_save = abfd->tdata.any;
 661   if (! srec_mkobject (abfd) || ! srec_scan (abfd))
 662     {
 663       if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
 664         bfd_release (abfd, abfd->tdata.any);
 665       abfd->tdata.any = tdata_save;
 666       return NULL;
 667     }
 668
 669   if (abfd->symcount > 0)
 670     abfd->flags |= HAS_SYMS;
 671
 672   return _bfd_no_cleanup;
 673 }
 674
 675 /* Check whether an existing file is an S-record file with symbols.  */
 676
 677 static bfd_cleanup
 678 symbolsrec_object_p (bfd *abfd)
 679 {
 680   void * tdata_save;
 681   char b[2];
 682
 683   srec_init ();
 684
 685   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
 686       || bfd_bread (b, (bfd_size_type) 2, abfd) != 2)
 687     return NULL;
 688
 689   if (b[0] != '$' || b[1] != '$')
 690     {
 691       bfd_set_error (bfd_error_wrong_format);
 692       return NULL;
 693     }
 694
 695   tdata_save = abfd->tdata.any;
 696   if (! srec_mkobject (abfd) || ! srec_scan (abfd))
 697     {
 698       if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
 699         bfd_release (abfd, abfd->tdata.any);
 700       abfd->tdata.any = tdata_save;
 701       return NULL;
 702     }
 703
 704   if (abfd->symcount > 0)
 705     abfd->flags |= HAS_SYMS;
 706
 707   return _bfd_no_cleanup;
 708 }
 709
 710 /* Read in the contents of a section in an S-record file.  */
 711
 712 static bfd_boolean
 713 srec_read_section (bfd *abfd, asection *section, bfd_byte *contents)
 714 {
 715   int c;
 716   bfd_size_type sofar = 0;
 717   bfd_boolean error = FALSE;
 718   bfd_byte *buf = NULL;
 719   size_t bufsize = 0;
 720
 721   if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
 722     goto error_return;
 723
 724   while ((c = srec_get_byte (abfd, &error)) != EOF)
 725     {
 726       bfd_byte hdr[3];
 727       unsigned int bytes;
 728       bfd_vma address;
 729       bfd_byte *data;
 730
 731       if (c == '\r' || c == '\n')
 732         continue;
 733
 734       /* This is called after srec_scan has already been called, so we
 735          ought to know the exact format.  */
 736       BFD_ASSERT (c == 'S');
 737
 738       if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)
 739         goto error_return;
 740
 741       BFD_ASSERT (ISHEX (hdr[1]) && ISHEX (hdr[2]));
 742
 743       bytes = HEX (hdr + 1);
 744
 745       if (bytes * 2 > bufsize)
 746         {
 747           free (buf);
 748           buf = (bfd_byte *) bfd_malloc ((bfd_size_type) bytes * 2);
 749           if (buf == NULL)
 750             goto error_return;
 751           bufsize = bytes * 2;
 752         }
 753
 754       if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2)
 755         goto error_return;
 756
 757       address = 0;
 758       data = buf;
 759       switch (hdr[0])
 760         {
 761         default:
 762           BFD_ASSERT (sofar == section->size);
 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               BFD_ASSERT (sofar == section->size);
 787               free (buf);
 788               return TRUE;
 789             }
 790
 791           /* Don't consider checksum.  */
 792           --bytes;
 793
 794           while (bytes-- != 0)
 795             {
 796               contents[sofar] = HEX (data);
 797               data += 2;
 798               ++sofar;
 799             }
 800
 801           break;
 802         }
 803     }
 804
 805   if (error)
 806     goto error_return;
 807
 808   BFD_ASSERT (sofar == section->size);
 809
 810   free (buf);
 811   return TRUE;
 812
 813  error_return:
 814   free (buf);
 815   return FALSE;
 816 }
 817
 818 /* Get the contents of a section in an S-record file.  */
 819
 820 static bfd_boolean
 821 srec_get_section_contents (bfd *abfd,
 822                            asection *section,
 823                            void * location,
 824                            file_ptr offset,
 825                            bfd_size_type count)
 826 {
 827   if (count == 0)
 828     return TRUE;
 829
 830   if (offset + count < count
 831       || offset + count > section->size)
 832     {
 833       bfd_set_error (bfd_error_invalid_operation);
 834       return FALSE;
 835     }
 836
 837   if (section->used_by_bfd == NULL)
 838     {
 839       section->used_by_bfd = bfd_alloc (abfd, section->size);
 840       if (section->used_by_bfd == NULL)
 841         return FALSE;
 842
 843       if (! srec_read_section (abfd, section,
 844                                (bfd_byte *) section->used_by_bfd))
 845         return FALSE;
 846     }
 847
 848   memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
 849           (size_t) count);
 850
 851   return TRUE;
 852 }
 853
 854 /* Set the architecture.  We accept an unknown architecture here.  */
 855
 856 static bfd_boolean
 857 srec_set_arch_mach (bfd *abfd, enum bfd_architecture arch, unsigned long mach)
 858 {
 859   if (arch != bfd_arch_unknown)
 860     return bfd_default_set_arch_mach (abfd, arch, mach);
 861
 862   abfd->arch_info = & bfd_default_arch_struct;
 863   return TRUE;
 864 }
 865
 866 /* We have to save up all the Srecords for a splurge before output.  */
 867
 868 static bfd_boolean
 869 srec_set_section_contents (bfd *abfd,
 870                            sec_ptr section,
 871                            const void * location,
 872                            file_ptr offset,
 873                            bfd_size_type bytes_to_do)
 874 {
 875   int opb = bfd_octets_per_byte (abfd, NULL);
 876   tdata_type *tdata = abfd->tdata.srec_data;
 877   srec_data_list_type *entry;
 878
 879   entry = (srec_data_list_type *) bfd_alloc (abfd, sizeof (* entry));
 880   if (entry == NULL)
 881     return FALSE;
 882
 883   if (bytes_to_do
 884       && (section->flags & SEC_ALLOC)
 885       && (section->flags & SEC_LOAD))
 886     {
 887       bfd_byte *data;
 888
 889       data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do);
 890       if (data == NULL)
 891         return FALSE;
 892       memcpy ((void *) data, location, (size_t) bytes_to_do);
 893
 894       /* If _bfd_srec_forceS3 is TRUE then always select S3 records,
 895          regardless of the size of the addresses.  */
 896       if (_bfd_srec_forceS3)
 897         tdata->type = 3;
 898       else if ((section->lma + (offset + bytes_to_do) / opb - 1) <= 0xffff)
 899         ;  /* The default, S1, is OK.  */
 900       else if ((section->lma + (offset + bytes_to_do) / opb - 1) <= 0xffffff
 901                && tdata->type <= 2)
 902         tdata->type = 2;
 903       else
 904         tdata->type = 3;
 905
 906       entry->data = data;
 907       entry->where = section->lma + offset / opb;
 908       entry->size = bytes_to_do;
 909
 910       /* Sort the records by address.  Optimize for the common case of
 911          adding a record to the end of the list.  */
 912       if (tdata->tail != NULL
 913           && entry->where >= tdata->tail->where)
 914         {
 915           tdata->tail->next = entry;
 916           entry->next = NULL;
 917           tdata->tail = entry;
 918         }
 919       else
 920         {
 921           srec_data_list_type **look;
 922
 923           for (look = &tdata->head;
 924                *look != NULL && (*look)->where < entry->where;
 925                look = &(*look)->next)
 926             ;
 927           entry->next = *look;
 928           *look = entry;
 929           if (entry->next == NULL)
 930             tdata->tail = entry;
 931         }
 932     }
 933   return TRUE;
 934 }
 935
 936 /* Write a record of type, of the supplied number of bytes. The
 937    supplied bytes and length don't have a checksum. That's worked out
 938    here.  */
 939
 940 static bfd_boolean
 941 srec_write_record (bfd *abfd,
 942                    unsigned int type,
 943                    bfd_vma address,
 944                    const bfd_byte *data,
 945                    const bfd_byte *end)
 946 {
 947   char buffer[2 * MAXCHUNK + 6];
 948   unsigned int check_sum = 0;
 949   const bfd_byte *src = data;
 950   char *dst = buffer;
 951   char *length;
 952   bfd_size_type wrlen;
 953
 954   *dst++ = 'S';
 955   *dst++ = '0' + type;
 956
 957   length = dst;
 958   dst += 2;                     /* Leave room for dst.  */
 959
 960   switch (type)
 961     {
 962     case 3:
 963     case 7:
 964       TOHEX (dst, (address >> 24), check_sum);
 965       dst += 2;
 966       /* Fall through.  */
 967     case 8:
 968     case 2:
 969       TOHEX (dst, (address >> 16), check_sum);
 970       dst += 2;
 971       /* Fall through.  */
 972     case 9:
 973     case 1:
 974     case 0:
 975       TOHEX (dst, (address >> 8), check_sum);
 976       dst += 2;
 977       TOHEX (dst, (address), check_sum);
 978       dst += 2;
 979       break;
 980
 981     }
 982   for (src = data; src < end; src++)
 983     {
 984       TOHEX (dst, *src, check_sum);
 985       dst += 2;
 986     }
 987
 988   /* Fill in the length.  */
 989   TOHEX (length, (dst - length) / 2, check_sum);
 990   check_sum &= 0xff;
 991   check_sum = 255 - check_sum;
 992   TOHEX (dst, check_sum, check_sum);
 993   dst += 2;
 994
 995   *dst++ = '\r';
 996   *dst++ = '\n';
 997   wrlen = dst - buffer;
 998
 999   return bfd_bwrite ((void *) buffer, wrlen, abfd) == wrlen;
1000 }
1001
1002 static bfd_boolean
1003 srec_write_header (bfd *abfd)
1004 {
1005   unsigned int len = strlen (bfd_get_filename (abfd));
1006
1007   /* I'll put an arbitrary 40 char limit on header size.  */
1008   if (len > 40)
1009     len = 40;
1010
1011   return srec_write_record (abfd, 0, (bfd_vma) 0,
1012                             (bfd_byte *) bfd_get_filename (abfd),
1013                             (bfd_byte *) bfd_get_filename (abfd) + len);
1014 }
1015
1016 static bfd_boolean
1017 srec_write_section (bfd *abfd,
1018                     tdata_type *tdata,
1019                     srec_data_list_type *list)
1020 {
1021   unsigned int octets_written = 0;
1022   bfd_byte *location = list->data;
1023
1024   /* Validate number of data bytes to write.  The srec length byte
1025      counts the address, data and crc bytes.  S1 (tdata->type == 1)
1026      records have two address bytes, S2 (tdata->type == 2) records
1027      have three, and S3 (tdata->type == 3) records have four.
1028      The total length can't exceed 255, and a zero data length will
1029      spin for a long time.  */
1030   if (_bfd_srec_len == 0)
1031     _bfd_srec_len = 1;
1032   else if (_bfd_srec_len > MAXCHUNK - tdata->type - 2)
1033     _bfd_srec_len = MAXCHUNK - tdata->type - 2;
1034
1035   while (octets_written < list->size)
1036     {
1037       bfd_vma address;
1038       unsigned int octets_this_chunk = list->size - octets_written;
1039
1040       if (octets_this_chunk > _bfd_srec_len)
1041         octets_this_chunk = _bfd_srec_len;
1042
1043       address = list->where + (octets_written
1044                                / bfd_octets_per_byte (abfd, NULL));
1045
1046       if (! srec_write_record (abfd,
1047                                tdata->type,
1048                                address,
1049                                location,
1050                                location + octets_this_chunk))
1051         return FALSE;
1052
1053       octets_written += octets_this_chunk;
1054       location += octets_this_chunk;
1055     }
1056
1057   return TRUE;
1058 }
1059
1060 static bfd_boolean
1061 srec_write_terminator (bfd *abfd, tdata_type *tdata)
1062 {
1063   return srec_write_record (abfd, 10 - tdata->type,
1064                             abfd->start_address, NULL, NULL);
1065 }
1066
1067 static bfd_boolean
1068 srec_write_symbols (bfd *abfd)
1069 {
1070   /* Dump out the symbols of a bfd.  */
1071   int i;
1072   int count = bfd_get_symcount (abfd);
1073
1074   if (count)
1075     {
1076       bfd_size_type len;
1077       asymbol **table = bfd_get_outsymbols (abfd);
1078
1079       len = strlen (bfd_get_filename (abfd));
1080       if (bfd_bwrite ("$$ ", (bfd_size_type) 3, abfd) != 3
1081           || bfd_bwrite (bfd_get_filename (abfd), len, abfd) != len
1082           || bfd_bwrite ("\r\n", (bfd_size_type) 2, abfd) != 2)
1083         return FALSE;
1084
1085       for (i = 0; i < count; i++)
1086         {
1087           asymbol *s = table[i];
1088
1089           if (! bfd_is_local_label (abfd, s)
1090               && (s->flags & BSF_DEBUGGING) == 0
1091               && s->section != NULL
1092               && s->section->output_section != NULL)
1093             {
1094               /* Just dump out non debug symbols.  */
1095               char buf[43], *p;
1096
1097               len = strlen (s->name);
1098               if (bfd_bwrite ("  ", (bfd_size_type) 2, abfd) != 2
1099                   || bfd_bwrite (s->name, len, abfd) != len)
1100                 return FALSE;
1101
1102               sprintf_vma (buf + 2, (s->value
1103                                      + s->section->output_section->lma
1104                                      + s->section->output_offset));
1105               p = buf + 2;
1106               while (p[0] == '0' && p[1] != 0)
1107                 p++;
1108               len = strlen (p);
1109               p[len] = '\r';
1110               p[len + 1] = '\n';
1111               *--p = '$';
1112               *--p = ' ';
1113               len += 4;
1114               if (bfd_bwrite (p, len, abfd) != len)
1115                 return FALSE;
1116             }
1117         }
1118       if (bfd_bwrite ("$$ \r\n", (bfd_size_type) 5, abfd) != 5)
1119         return FALSE;
1120     }
1121
1122   return TRUE;
1123 }
1124
1125 static bfd_boolean
1126 internal_srec_write_object_contents (bfd *abfd, int symbols)
1127 {
1128   tdata_type *tdata = abfd->tdata.srec_data;
1129   srec_data_list_type *list;
1130
1131   if (symbols)
1132     {
1133       if (! srec_write_symbols (abfd))
1134         return FALSE;
1135     }
1136
1137   if (! srec_write_header (abfd))
1138     return FALSE;
1139
1140   /* Now wander though all the sections provided and output them.  */
1141   list = tdata->head;
1142
1143   while (list != (srec_data_list_type *) NULL)
1144     {
1145       if (! srec_write_section (abfd, tdata, list))
1146         return FALSE;
1147       list = list->next;
1148     }
1149   return srec_write_terminator (abfd, tdata);
1150 }
1151
1152 static bfd_boolean
1153 srec_write_object_contents (bfd *abfd)
1154 {
1155   return internal_srec_write_object_contents (abfd, 0);
1156 }
1157
1158 static bfd_boolean
1159 symbolsrec_write_object_contents (bfd *abfd)
1160 {
1161   return internal_srec_write_object_contents (abfd, 1);
1162 }
1163
1164 static int
1165 srec_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
1166                      struct bfd_link_info *info ATTRIBUTE_UNUSED)
1167 {
1168   return 0;
1169 }
1170
1171 /* Return the amount of memory needed to read the symbol table.  */
1172
1173 static long
1174 srec_get_symtab_upper_bound (bfd *abfd)
1175 {
1176   return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *);
1177 }
1178
1179 /* Return the symbol table.  */
1180
1181 static long
1182 srec_canonicalize_symtab (bfd *abfd, asymbol **alocation)
1183 {
1184   bfd_size_type symcount = bfd_get_symcount (abfd);
1185   asymbol *csymbols;
1186   unsigned int i;
1187
1188   csymbols = abfd->tdata.srec_data->csymbols;
1189   if (csymbols == NULL && symcount != 0)
1190     {
1191       asymbol *c;
1192       struct srec_symbol *s;
1193
1194       csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));
1195       if (csymbols == NULL)
1196         return -1;
1197       abfd->tdata.srec_data->csymbols = csymbols;
1198
1199       for (s = abfd->tdata.srec_data->symbols, c = csymbols;
1200            s != NULL;
1201            s = s->next, ++c)
1202         {
1203           c->the_bfd = abfd;
1204           c->name = s->name;
1205           c->value = s->val;
1206           c->flags = BSF_GLOBAL;
1207           c->section = bfd_abs_section_ptr;
1208           c->udata.p = NULL;
1209         }
1210     }
1211
1212   for (i = 0; i < symcount; i++)
1213     *alocation++ = csymbols++;
1214   *alocation = NULL;
1215
1216   return symcount;
1217 }
1218
1219 static void
1220 srec_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
1221                       asymbol *symbol,
1222                       symbol_info *ret)
1223 {
1224   bfd_symbol_info (symbol, ret);
1225 }
1226
1227 static void
1228 srec_print_symbol (bfd *abfd,
1229                    void * afile,
1230                    asymbol *symbol,
1231                    bfd_print_symbol_type how)
1232 {
1233   FILE *file = (FILE *) afile;
1234
1235   switch (how)
1236     {
1237     case bfd_print_symbol_name:
1238       fprintf (file, "%s", symbol->name);
1239       break;
1240     default:
1241       bfd_print_symbol_vandf (abfd, (void *) file, symbol);
1242       fprintf (file, " %-5s %s",
1243                symbol->section->name,
1244                symbol->name);
1245     }
1246 }
1247
1248 #define srec_close_and_cleanup                    _bfd_generic_close_and_cleanup
1249 #define srec_bfd_free_cached_info                 _bfd_generic_bfd_free_cached_info
1250 #define srec_new_section_hook                     _bfd_generic_new_section_hook
1251 #define srec_bfd_is_target_special_symbol         _bfd_bool_bfd_asymbol_false
1252 #define srec_bfd_is_local_label_name              bfd_generic_is_local_label_name
1253 #define srec_get_lineno                           _bfd_nosymbols_get_lineno
1254 #define srec_find_nearest_line                    _bfd_nosymbols_find_nearest_line
1255 #define srec_find_line                            _bfd_nosymbols_find_line
1256 #define srec_find_inliner_info                    _bfd_nosymbols_find_inliner_info
1257 #define srec_make_empty_symbol                    _bfd_generic_make_empty_symbol
1258 #define srec_get_symbol_version_string            _bfd_nosymbols_get_symbol_version_string
1259 #define srec_bfd_make_debug_symbol                _bfd_nosymbols_bfd_make_debug_symbol
1260 #define srec_read_minisymbols                     _bfd_generic_read_minisymbols
1261 #define srec_minisymbol_to_symbol                 _bfd_generic_minisymbol_to_symbol
1262 #define srec_get_section_contents_in_window       _bfd_generic_get_section_contents_in_window
1263 #define srec_bfd_get_relocated_section_contents   bfd_generic_get_relocated_section_contents
1264 #define srec_bfd_relax_section                    bfd_generic_relax_section
1265 #define srec_bfd_gc_sections                      bfd_generic_gc_sections
1266 #define srec_bfd_lookup_section_flags             bfd_generic_lookup_section_flags
1267 #define srec_bfd_merge_sections                   bfd_generic_merge_sections
1268 #define srec_bfd_is_group_section                 bfd_generic_is_group_section
1269 #define srec_bfd_group_name                       bfd_generic_group_name
1270 #define srec_bfd_discard_group                    bfd_generic_discard_group
1271 #define srec_section_already_linked               _bfd_generic_section_already_linked
1272 #define srec_bfd_define_common_symbol             bfd_generic_define_common_symbol
1273 #define srec_bfd_link_hide_symbol                 _bfd_generic_link_hide_symbol
1274 #define srec_bfd_define_start_stop                bfd_generic_define_start_stop
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_bool_bfd_false_error,
1313     srec_mkobject,
1314     _bfd_generic_mkarchive,
1315     _bfd_bool_bfd_false_error,
1316   },
1317   {                             /* bfd_write_contents.  */
1318     _bfd_bool_bfd_false_error,
1319     srec_write_object_contents,
1320     _bfd_write_archive_contents,
1321     _bfd_bool_bfd_false_error,
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_bool_bfd_false_error,
1369     srec_mkobject,
1370     _bfd_generic_mkarchive,
1371     _bfd_bool_bfd_false_error,
1372   },
1373   {                             /* bfd_write_contents.  */
1374     _bfd_bool_bfd_false_error,
1375     symbolsrec_write_object_contents,
1376     _bfd_write_archive_contents,
1377     _bfd_bool_bfd_false_error,
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 };