bfd/srec.c

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