bfd/srec.c

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