bfd/srec.c

   1 /* BFD back-end for s-record objects.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004, 2005
   4    Free Software Foundation, Inc.
   5    Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23 /* SUBSECTION
  24         S-Record handling
  25
  26    DESCRIPTION
  27
  28         Ordinary S-Records cannot hold anything but addresses and
  29         data, so that's all that we implement.
  30
  31         The only interesting thing is that S-Records may come out of
  32         order and there is no header, so an initial scan is required
  33         to discover the minimum and maximum addresses used to create
  34         the vma and size of the only section we create.  We
  35         arbitrarily call this section ".text".
  36
  37         When bfd_get_section_contents is called the file is read
  38         again, and this time the data is placed into a bfd_alloc'd
  39         area.
  40
  41         Any number of sections may be created for output, we save them
  42         up and output them when it's time to close the bfd.
  43
  44         An s record looks like:
  45
  46    EXAMPLE
  47         S<type><length><address><data><checksum>
  48
  49    DESCRIPTION
  50         Where
  51         o length
  52         is the number of bytes following upto the checksum. Note that
  53         this is not the number of chars following, since it takes two
  54         chars to represent a byte.
  55         o type
  56         is one of:
  57         0) header record
  58         1) two byte address data record
  59         2) three byte address data record
  60         3) four byte address data record
  61         7) four byte address termination record
  62         8) three byte address termination record
  63         9) two byte address termination record
  64
  65         o address
  66         is the start address of the data following, or in the case of
  67         a termination record, the start address of the image
  68         o data
  69         is the data.
  70         o checksum
  71         is the sum of all the raw byte data in the record, from the length
  72         upwards, modulo 256 and subtracted from 255.
  73
  74    SUBSECTION
  75         Symbol S-Record handling
  76
  77    DESCRIPTION
  78         Some ICE equipment understands an addition to the standard
  79         S-Record format; symbols and their addresses can be sent
  80         before the data.
  81
  82         The format of this is:
  83         ($$ <modulename>
  84                 (<space> <symbol> <address>)*)
  85         $$
  86
  87         so a short symbol table could look like:
  88
  89    EXAMPLE
  90         $$ flash.x
  91         $$ flash.c
  92           _port6 $0
  93           _delay $4
  94           _start $14
  95           _etext $8036
  96           _edata $8036
  97           _end $8036
  98         $$
  99
 100    DESCRIPTION
 101         We allow symbols to be anywhere in the data stream - the module names
 102         are always ignored.  */
 103
 104 #include "bfd.h"
 105 #include "sysdep.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 = 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 = 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 = bfd_malloc (alc + 1);
 365               if (symbuf == NULL)
 366                 goto error_return;
 367
 368               p = symbuf;
 369
 370               *p++ = c;
 371               while ((c = srec_get_byte (abfd, &error)) != EOF
 372                      && ! ISSPACE (c))
 373                 {
 374                   if ((bfd_size_type) (p - symbuf) >= alc)
 375                     {
 376                       char *n;
 377
 378                       alc *= 2;
 379                       n = bfd_realloc (symbuf, alc + 1);
 380                       if (n == NULL)
 381                         goto error_return;
 382                       p = n + (p - symbuf);
 383                       symbuf = n;
 384                     }
 385
 386                   *p++ = c;
 387                 }
 388
 389               if (c == EOF)
 390                 {
 391                   srec_bad_byte (abfd, lineno, c, error);
 392                   goto error_return;
 393                 }
 394
 395               *p++ = '\0';
 396               symname = bfd_alloc (abfd, (bfd_size_type) (p - symbuf));
 397               if (symname == NULL)
 398                 goto error_return;
 399               strcpy (symname, symbuf);
 400               free (symbuf);
 401               symbuf = NULL;
 402
 403               while ((c = srec_get_byte (abfd, &error)) != EOF
 404                      && (c == ' ' || c == '\t'))
 405                 ;
 406               if (c == EOF)
 407                 {
 408                   srec_bad_byte (abfd, lineno, c, error);
 409                   goto error_return;
 410                 }
 411
 412               /* Skip a dollar sign before the hex value.  */
 413               if (c == '$')
 414                 {
 415                   c = srec_get_byte (abfd, &error);
 416                   if (c == EOF)
 417                     {
 418                       srec_bad_byte (abfd, lineno, c, error);
 419                       goto error_return;
 420                     }
 421                 }
 422
 423               symval = 0;
 424               while (ISHEX (c))
 425                 {
 426                   symval <<= 4;
 427                   symval += NIBBLE (c);
 428                   c = srec_get_byte (abfd, &error);
 429                 }
 430
 431               if (! srec_new_symbol (abfd, symname, symval))
 432                 goto error_return;
 433             }
 434           while (c == ' ' || c == '\t')
 435             ;
 436
 437           if (c == '\n')
 438             ++lineno;
 439           else if (c != '\r')
 440             {
 441               srec_bad_byte (abfd, lineno, c, error);
 442               goto error_return;
 443             }
 444
 445           break;
 446
 447         case 'S':
 448           {
 449             file_ptr pos;
 450             char hdr[3];
 451             unsigned int bytes;
 452             bfd_vma address;
 453             bfd_byte *data;
 454
 455             /* Starting an S-record.  */
 456
 457             pos = bfd_tell (abfd) - 1;
 458
 459             if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)
 460               goto error_return;
 461
 462             if (! ISHEX (hdr[1]) || ! ISHEX (hdr[2]))
 463               {
 464                 if (! ISHEX (hdr[1]))
 465                   c = hdr[1];
 466                 else
 467                   c = hdr[2];
 468                 srec_bad_byte (abfd, lineno, c, error);
 469                 goto error_return;
 470               }
 471
 472             bytes = HEX (hdr + 1);
 473             if (bytes * 2 > bufsize)
 474               {
 475                 if (buf != NULL)
 476                   free (buf);
 477                 buf = bfd_malloc ((bfd_size_type) bytes * 2);
 478                 if (buf == NULL)
 479                   goto error_return;
 480                 bufsize = bytes * 2;
 481               }
 482
 483             if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2)
 484               goto error_return;
 485
 486             /* Ignore the checksum byte.  */
 487             --bytes;
 488
 489             address = 0;
 490             data = buf;
 491             switch (hdr[0])
 492               {
 493               case '0':
 494               case '5':
 495                 /* Prologue--ignore the file name, but stop building a
 496                    section at this point.  */
 497                 sec = NULL;
 498                 break;
 499
 500               case '3':
 501                 address = HEX (data);
 502                 data += 2;
 503                 --bytes;
 504                 /* Fall through.  */
 505               case '2':
 506                 address = (address << 8) | HEX (data);
 507                 data += 2;
 508                 --bytes;
 509                 /* Fall through.  */
 510               case '1':
 511                 address = (address << 8) | HEX (data);
 512                 data += 2;
 513                 address = (address << 8) | HEX (data);
 514                 data += 2;
 515                 bytes -= 2;
 516
 517                 if (sec != NULL
 518                     && sec->vma + sec->size == address)
 519                   {
 520                     /* This data goes at the end of the section we are
 521                        currently building.  */
 522                     sec->size += bytes;
 523                   }
 524                 else
 525                   {
 526                     char secbuf[20];
 527                     char *secname;
 528                     bfd_size_type amt;
 529
 530                     sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
 531                     amt = strlen (secbuf) + 1;
 532                     secname = bfd_alloc (abfd, amt);
 533                     strcpy (secname, secbuf);
 534                     sec = bfd_make_section (abfd, secname);
 535                     if (sec == NULL)
 536                       goto error_return;
 537                     sec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
 538                     sec->vma = address;
 539                     sec->lma = address;
 540                     sec->size = bytes;
 541                     sec->filepos = pos;
 542                   }
 543                 break;
 544
 545               case '7':
 546                 address = HEX (data);
 547                 data += 2;
 548                 /* Fall through.  */
 549               case '8':
 550                 address = (address << 8) | HEX (data);
 551                 data += 2;
 552                 /* Fall through.  */
 553               case '9':
 554                 address = (address << 8) | HEX (data);
 555                 data += 2;
 556                 address = (address << 8) | HEX (data);
 557                 data += 2;
 558
 559                 /* This is a termination record.  */
 560                 abfd->start_address = address;
 561
 562                 if (buf != NULL)
 563                   free (buf);
 564
 565                 return TRUE;
 566               }
 567           }
 568           break;
 569         }
 570     }
 571
 572   if (error)
 573     goto error_return;
 574
 575   if (buf != NULL)
 576     free (buf);
 577
 578   return TRUE;
 579
 580  error_return:
 581   if (symbuf != NULL)
 582     free (symbuf);
 583   if (buf != NULL)
 584     free (buf);
 585   return FALSE;
 586 }
 587
 588 /* Check whether an existing file is an S-record file.  */
 589
 590 static const bfd_target *
 591 srec_object_p (bfd *abfd)
 592 {
 593   void * tdata_save;
 594   bfd_byte b[4];
 595
 596   srec_init ();
 597
 598   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
 599       || bfd_bread (b, (bfd_size_type) 4, abfd) != 4)
 600     return NULL;
 601
 602   if (b[0] != 'S' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
 603     {
 604       bfd_set_error (bfd_error_wrong_format);
 605       return NULL;
 606     }
 607
 608   tdata_save = abfd->tdata.any;
 609   if (! srec_mkobject (abfd) || ! srec_scan (abfd))
 610     {
 611       if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
 612         bfd_release (abfd, abfd->tdata.any);
 613       abfd->tdata.any = tdata_save;
 614       return NULL;
 615     }
 616
 617   if (abfd->symcount > 0)
 618     abfd->flags |= HAS_SYMS;
 619
 620   return abfd->xvec;
 621 }
 622
 623 /* Check whether an existing file is an S-record file with symbols.  */
 624
 625 static const bfd_target *
 626 symbolsrec_object_p (bfd *abfd)
 627 {
 628   void * tdata_save;
 629   char b[2];
 630
 631   srec_init ();
 632
 633   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
 634       || bfd_bread (b, (bfd_size_type) 2, abfd) != 2)
 635     return NULL;
 636
 637   if (b[0] != '$' || b[1] != '$')
 638     {
 639       bfd_set_error (bfd_error_wrong_format);
 640       return NULL;
 641     }
 642
 643   tdata_save = abfd->tdata.any;
 644   if (! srec_mkobject (abfd) || ! srec_scan (abfd))
 645     {
 646       if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
 647         bfd_release (abfd, abfd->tdata.any);
 648       abfd->tdata.any = tdata_save;
 649       return NULL;
 650     }
 651
 652   if (abfd->symcount > 0)
 653     abfd->flags |= HAS_SYMS;
 654
 655   return abfd->xvec;
 656 }
 657
 658 /* Read in the contents of a section in an S-record file.  */
 659
 660 static bfd_boolean
 661 srec_read_section (bfd *abfd, asection *section, bfd_byte *contents)
 662 {
 663   int c;
 664   bfd_size_type sofar = 0;
 665   bfd_boolean error = FALSE;
 666   bfd_byte *buf = NULL;
 667   size_t bufsize = 0;
 668
 669   if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
 670     goto error_return;
 671
 672   while ((c = srec_get_byte (abfd, &error)) != EOF)
 673     {
 674       bfd_byte hdr[3];
 675       unsigned int bytes;
 676       bfd_vma address;
 677       bfd_byte *data;
 678
 679       if (c == '\r' || c == '\n')
 680         continue;
 681
 682       /* This is called after srec_scan has already been called, so we
 683          ought to know the exact format.  */
 684       BFD_ASSERT (c == 'S');
 685
 686       if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)
 687         goto error_return;
 688
 689       BFD_ASSERT (ISHEX (hdr[1]) && ISHEX (hdr[2]));
 690
 691       bytes = HEX (hdr + 1);
 692
 693       if (bytes * 2 > bufsize)
 694         {
 695           if (buf != NULL)
 696             free (buf);
 697           buf = bfd_malloc ((bfd_size_type) bytes * 2);
 698           if (buf == NULL)
 699             goto error_return;
 700           bufsize = bytes * 2;
 701         }
 702
 703       if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2)
 704         goto error_return;
 705
 706       address = 0;
 707       data = buf;
 708       switch (hdr[0])
 709         {
 710         default:
 711           BFD_ASSERT (sofar == section->size);
 712           if (buf != NULL)
 713             free (buf);
 714           return TRUE;
 715
 716         case '3':
 717           address = HEX (data);
 718           data += 2;
 719           --bytes;
 720           /* Fall through.  */
 721         case '2':
 722           address = (address << 8) | HEX (data);
 723           data += 2;
 724           --bytes;
 725           /* Fall through.  */
 726         case '1':
 727           address = (address << 8) | HEX (data);
 728           data += 2;
 729           address = (address << 8) | HEX (data);
 730           data += 2;
 731           bytes -= 2;
 732
 733           if (address != section->vma + sofar)
 734             {
 735               /* We've come to the end of this section.  */
 736               BFD_ASSERT (sofar == section->size);
 737               if (buf != NULL)
 738                 free (buf);
 739               return TRUE;
 740             }
 741
 742           /* Don't consider checksum.  */
 743           --bytes;
 744
 745           while (bytes-- != 0)
 746             {
 747               contents[sofar] = HEX (data);
 748               data += 2;
 749               ++sofar;
 750             }
 751
 752           break;
 753         }
 754     }
 755
 756   if (error)
 757     goto error_return;
 758
 759   BFD_ASSERT (sofar == section->size);
 760
 761   if (buf != NULL)
 762     free (buf);
 763
 764   return TRUE;
 765
 766  error_return:
 767   if (buf != NULL)
 768     free (buf);
 769   return FALSE;
 770 }
 771
 772 /* Get the contents of a section in an S-record file.  */
 773
 774 static bfd_boolean
 775 srec_get_section_contents (bfd *abfd,
 776                            asection *section,
 777                            void * location,
 778                            file_ptr offset,
 779                            bfd_size_type count)
 780 {
 781   if (section->used_by_bfd == NULL)
 782     {
 783       section->used_by_bfd = bfd_alloc (abfd, section->size);
 784       if (section->used_by_bfd == NULL && section->size != 0)
 785         return FALSE;
 786
 787       if (! srec_read_section (abfd, section, section->used_by_bfd))
 788         return FALSE;
 789     }
 790
 791   memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
 792           (size_t) count);
 793
 794   return TRUE;
 795 }
 796
 797 /* Set the architecture.  We accept an unknown architecture here.  */
 798
 799 static bfd_boolean
 800 srec_set_arch_mach (bfd *abfd, enum bfd_architecture arch, unsigned long mach)
 801 {
 802   if (arch != bfd_arch_unknown)
 803     return bfd_default_set_arch_mach (abfd, arch, mach);
 804
 805   abfd->arch_info = & bfd_default_arch_struct;
 806   return TRUE;
 807 }
 808
 809 /* We have to save up all the Srecords for a splurge before output.  */
 810
 811 static bfd_boolean
 812 srec_set_section_contents (bfd *abfd,
 813                            sec_ptr section,
 814                            const void * location,
 815                            file_ptr offset,
 816                            bfd_size_type bytes_to_do)
 817 {
 818   tdata_type *tdata = abfd->tdata.srec_data;
 819   srec_data_list_type *entry;
 820
 821   entry = bfd_alloc (abfd, sizeof (* entry));
 822   if (entry == NULL)
 823     return FALSE;
 824
 825   if (bytes_to_do
 826       && (section->flags & SEC_ALLOC)
 827       && (section->flags & SEC_LOAD))
 828     {
 829       bfd_byte *data;
 830
 831       data = bfd_alloc (abfd, bytes_to_do);
 832       if (data == NULL)
 833         return FALSE;
 834       memcpy ((void *) data, location, (size_t) bytes_to_do);
 835
 836       /* Ff S3Forced is TRUE then always select S3 records,
 837          regardless of the siez of the addresses.  */
 838       if (S3Forced)
 839         tdata->type = 3;
 840       else if ((section->lma + offset + bytes_to_do - 1) <= 0xffff)
 841         ;  /* The default, S1, is OK.  */
 842       else if ((section->lma + offset + bytes_to_do - 1) <= 0xffffff
 843                && tdata->type <= 2)
 844         tdata->type = 2;
 845       else
 846         tdata->type = 3;
 847
 848       entry->data = data;
 849       entry->where = section->lma + offset;
 850       entry->size = bytes_to_do;
 851
 852       /* Sort the records by address.  Optimize for the common case of
 853          adding a record to the end of the list.  */
 854       if (tdata->tail != NULL
 855           && entry->where >= tdata->tail->where)
 856         {
 857           tdata->tail->next = entry;
 858           entry->next = NULL;
 859           tdata->tail = entry;
 860         }
 861       else
 862         {
 863           srec_data_list_type **look;
 864
 865           for (look = &tdata->head;
 866                *look != NULL && (*look)->where < entry->where;
 867                look = &(*look)->next)
 868             ;
 869           entry->next = *look;
 870           *look = entry;
 871           if (entry->next == NULL)
 872             tdata->tail = entry;
 873         }
 874     }
 875   return TRUE;
 876 }
 877
 878 /* Write a record of type, of the supplied number of bytes. The
 879    supplied bytes and length don't have a checksum. That's worked out
 880    here.  */
 881
 882 static bfd_boolean
 883 srec_write_record (bfd *abfd,
 884                    unsigned int type,
 885                    bfd_vma address,
 886                    const bfd_byte *data,
 887                    const bfd_byte *end)
 888 {
 889   char buffer[2 * MAXCHUNK + 6];
 890   unsigned int check_sum = 0;
 891   const bfd_byte *src = data;
 892   char *dst = buffer;
 893   char *length;
 894   bfd_size_type wrlen;
 895
 896   *dst++ = 'S';
 897   *dst++ = '0' + type;
 898
 899   length = dst;
 900   dst += 2;                     /* Leave room for dst.  */
 901
 902   switch (type)
 903     {
 904     case 3:
 905     case 7:
 906       TOHEX (dst, (address >> 24), check_sum);
 907       dst += 2;
 908     case 8:
 909     case 2:
 910       TOHEX (dst, (address >> 16), check_sum);
 911       dst += 2;
 912     case 9:
 913     case 1:
 914     case 0:
 915       TOHEX (dst, (address >> 8), check_sum);
 916       dst += 2;
 917       TOHEX (dst, (address), check_sum);
 918       dst += 2;
 919       break;
 920
 921     }
 922   for (src = data; src < end; src++)
 923     {
 924       TOHEX (dst, *src, check_sum);
 925       dst += 2;
 926     }
 927
 928   /* Fill in the length.  */
 929   TOHEX (length, (dst - length) / 2, check_sum);
 930   check_sum &= 0xff;
 931   check_sum = 255 - check_sum;
 932   TOHEX (dst, check_sum, check_sum);
 933   dst += 2;
 934
 935   *dst++ = '\r';
 936   *dst++ = '\n';
 937   wrlen = dst - buffer;
 938
 939   return bfd_bwrite ((void *) buffer, wrlen, abfd) == wrlen;
 940 }
 941
 942 static bfd_boolean
 943 srec_write_header (bfd *abfd)
 944 {
 945   unsigned int len = strlen (abfd->filename);
 946
 947   /* I'll put an arbitrary 40 char limit on header size.  */
 948   if (len > 40)
 949     len = 40;
 950
 951   return srec_write_record (abfd, 0, (bfd_vma) 0,
 952                             (bfd_byte *) abfd->filename,
 953                             (bfd_byte *) abfd->filename + len);
 954 }
 955
 956 static bfd_boolean
 957 srec_write_section (bfd *abfd,
 958                     tdata_type *tdata,
 959                     srec_data_list_type *list)
 960 {
 961   unsigned int octets_written = 0;
 962   bfd_byte *location = list->data;
 963
 964   /* Validate number of data bytes to write.  The srec length byte
 965      counts the address, data and crc bytes.  S1 (tdata->type == 1)
 966      records have two address bytes, S2 (tdata->type == 2) records
 967      have three, and S3 (tdata->type == 3) records have four.
 968      The total length can't exceed 255, and a zero data length will
 969      spin for a long time.  */
 970   if (Chunk == 0)
 971     Chunk = 1;
 972   else if (Chunk > MAXCHUNK - tdata->type - 2)
 973     Chunk = MAXCHUNK - tdata->type - 2;
 974
 975   while (octets_written < list->size)
 976     {
 977       bfd_vma address;
 978       unsigned int octets_this_chunk = list->size - octets_written;
 979
 980       if (octets_this_chunk > Chunk)
 981         octets_this_chunk = Chunk;
 982
 983       address = list->where + octets_written / bfd_octets_per_byte (abfd);
 984
 985       if (! srec_write_record (abfd,
 986                                tdata->type,
 987                                address,
 988                                location,
 989                                location + octets_this_chunk))
 990         return FALSE;
 991
 992       octets_written += octets_this_chunk;
 993       location += octets_this_chunk;
 994     }
 995
 996   return TRUE;
 997 }
 998
 999 static bfd_boolean
1000 srec_write_terminator (bfd *abfd, tdata_type *tdata)
1001 {
1002   return srec_write_record (abfd, 10 - tdata->type,
1003                             abfd->start_address, NULL, NULL);
1004 }
1005
1006 static bfd_boolean
1007 srec_write_symbols (bfd *abfd)
1008 {
1009   /* Dump out the symbols of a bfd.  */
1010   int i;
1011   int count = bfd_get_symcount (abfd);
1012
1013   if (count)
1014     {
1015       bfd_size_type len;
1016       asymbol **table = bfd_get_outsymbols (abfd);
1017
1018       len = strlen (abfd->filename);
1019       if (bfd_bwrite ("$$ ", (bfd_size_type) 3, abfd) != 3
1020           || bfd_bwrite (abfd->filename, len, abfd) != len
1021           || bfd_bwrite ("\r\n", (bfd_size_type) 2, abfd) != 2)
1022         return FALSE;
1023
1024       for (i = 0; i < count; i++)
1025         {
1026           asymbol *s = table[i];
1027           if (! bfd_is_local_label (abfd, s)
1028               && (s->flags & BSF_DEBUGGING) == 0)
1029             {
1030               /* Just dump out non debug symbols.  */
1031               char buf[43], *p;
1032
1033               len = strlen (s->name);
1034               if (bfd_bwrite ("  ", (bfd_size_type) 2, abfd) != 2
1035                   || bfd_bwrite (s->name, len, abfd) != len)
1036                 return FALSE;
1037
1038               sprintf_vma (buf + 2, (s->value
1039                                      + s->section->output_section->lma
1040                                      + s->section->output_offset));
1041               p = buf + 2;
1042               while (p[0] == '0' && p[1] != 0)
1043                 p++;
1044               len = strlen (p);
1045               p[len] = '\r';
1046               p[len + 1] = '\n';
1047               *--p = '$';
1048               *--p = ' ';
1049               len += 4;
1050               if (bfd_bwrite (p, len, abfd) != len)
1051                 return FALSE;
1052             }
1053         }
1054       if (bfd_bwrite ("$$ \r\n", (bfd_size_type) 5, abfd) != 5)
1055         return FALSE;
1056     }
1057
1058   return TRUE;
1059 }
1060
1061 static bfd_boolean
1062 internal_srec_write_object_contents (bfd *abfd, int symbols)
1063 {
1064   tdata_type *tdata = abfd->tdata.srec_data;
1065   srec_data_list_type *list;
1066
1067   if (symbols)
1068     {
1069       if (! srec_write_symbols (abfd))
1070         return FALSE;
1071     }
1072
1073   if (! srec_write_header (abfd))
1074     return FALSE;
1075
1076   /* Now wander though all the sections provided and output them.  */
1077   list = tdata->head;
1078
1079   while (list != (srec_data_list_type *) NULL)
1080     {
1081       if (! srec_write_section (abfd, tdata, list))
1082         return FALSE;
1083       list = list->next;
1084     }
1085   return srec_write_terminator (abfd, tdata);
1086 }
1087
1088 static bfd_boolean
1089 srec_write_object_contents (bfd *abfd)
1090 {
1091   return internal_srec_write_object_contents (abfd, 0);
1092 }
1093
1094 static bfd_boolean
1095 symbolsrec_write_object_contents (bfd *abfd)
1096 {
1097   return internal_srec_write_object_contents (abfd, 1);
1098 }
1099
1100 static int
1101 srec_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
1102                      bfd_boolean exec ATTRIBUTE_UNUSED)
1103 {
1104   return 0;
1105 }
1106
1107 /* Return the amount of memory needed to read the symbol table.  */
1108
1109 static long
1110 srec_get_symtab_upper_bound (bfd *abfd)
1111 {
1112   return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *);
1113 }
1114
1115 /* Return the symbol table.  */
1116
1117 static long
1118 srec_canonicalize_symtab (bfd *abfd, asymbol **alocation)
1119 {
1120   bfd_size_type symcount = bfd_get_symcount (abfd);
1121   asymbol *csymbols;
1122   unsigned int i;
1123
1124   csymbols = abfd->tdata.srec_data->csymbols;
1125   if (csymbols == NULL)
1126     {
1127       asymbol *c;
1128       struct srec_symbol *s;
1129
1130       csymbols = bfd_alloc (abfd, symcount * sizeof (asymbol));
1131       if (csymbols == NULL && symcount != 0)
1132         return 0;
1133       abfd->tdata.srec_data->csymbols = csymbols;
1134
1135       for (s = abfd->tdata.srec_data->symbols, c = csymbols;
1136            s != NULL;
1137            s = s->next, ++c)
1138         {
1139           c->the_bfd = abfd;
1140           c->name = s->name;
1141           c->value = s->val;
1142           c->flags = BSF_GLOBAL;
1143           c->section = bfd_abs_section_ptr;
1144           c->udata.p = NULL;
1145         }
1146     }
1147
1148   for (i = 0; i < symcount; i++)
1149     *alocation++ = csymbols++;
1150   *alocation = NULL;
1151
1152   return symcount;
1153 }
1154
1155 static void
1156 srec_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
1157                       asymbol *symbol,
1158                       symbol_info *ret)
1159 {
1160   bfd_symbol_info (symbol, ret);
1161 }
1162
1163 static void
1164 srec_print_symbol (bfd *abfd,
1165                    void * afile,
1166                    asymbol *symbol,
1167                    bfd_print_symbol_type how)
1168 {
1169   FILE *file = (FILE *) afile;
1170
1171   switch (how)
1172     {
1173     case bfd_print_symbol_name:
1174       fprintf (file, "%s", symbol->name);
1175       break;
1176     default:
1177       bfd_print_symbol_vandf (abfd, (void *) file, symbol);
1178       fprintf (file, " %-5s %s",
1179                symbol->section->name,
1180                symbol->name);
1181     }
1182 }
1183
1184 #define srec_close_and_cleanup                    _bfd_generic_close_and_cleanup
1185 #define srec_bfd_free_cached_info                 _bfd_generic_bfd_free_cached_info
1186 #define srec_new_section_hook                     _bfd_generic_new_section_hook
1187 #define srec_bfd_is_target_special_symbol         ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
1188 #define srec_bfd_is_local_label_name              bfd_generic_is_local_label_name
1189 #define srec_get_lineno                           _bfd_nosymbols_get_lineno
1190 #define srec_find_nearest_line                    _bfd_nosymbols_find_nearest_line
1191 #define srec_find_inliner_info                    _bfd_nosymbols_find_inliner_info
1192 #define srec_make_empty_symbol                    _bfd_generic_make_empty_symbol
1193 #define srec_bfd_make_debug_symbol                _bfd_nosymbols_bfd_make_debug_symbol
1194 #define srec_read_minisymbols                     _bfd_generic_read_minisymbols
1195 #define srec_minisymbol_to_symbol                 _bfd_generic_minisymbol_to_symbol
1196 #define srec_get_reloc_upper_bound                ((long (*) (bfd *, asection *)) bfd_0l)
1197 #define srec_canonicalize_reloc                   ((long (*) (bfd *, asection *, arelent **, asymbol **)) bfd_0l)
1198 #define srec_bfd_reloc_type_lookup                _bfd_norelocs_bfd_reloc_type_lookup
1199 #define srec_get_section_contents_in_window       _bfd_generic_get_section_contents_in_window
1200 #define srec_bfd_get_relocated_section_contents   bfd_generic_get_relocated_section_contents
1201 #define srec_bfd_relax_section                    bfd_generic_relax_section
1202 #define srec_bfd_gc_sections                      bfd_generic_gc_sections
1203 #define srec_bfd_merge_sections                   bfd_generic_merge_sections
1204 #define srec_bfd_is_group_section                 bfd_generic_is_group_section
1205 #define srec_bfd_discard_group                    bfd_generic_discard_group
1206 #define srec_section_already_linked               _bfd_generic_section_already_linked
1207 #define srec_bfd_link_hash_table_create           _bfd_generic_link_hash_table_create
1208 #define srec_bfd_link_hash_table_free             _bfd_generic_link_hash_table_free
1209 #define srec_bfd_link_add_symbols                 _bfd_generic_link_add_symbols
1210 #define srec_bfd_link_just_syms                   _bfd_generic_link_just_syms
1211 #define srec_bfd_final_link                       _bfd_generic_final_link
1212 #define srec_bfd_link_split_section               _bfd_generic_link_split_section
1213
1214 const bfd_target srec_vec =
1215 {
1216   "srec",                       /* Name.  */
1217   bfd_target_srec_flavour,
1218   BFD_ENDIAN_UNKNOWN,           /* Target byte order.  */
1219   BFD_ENDIAN_UNKNOWN,           /* Target headers byte order.  */
1220   (HAS_RELOC | EXEC_P |         /* Object flags.  */
1221    HAS_LINENO | HAS_DEBUG |
1222    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1223   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1224    | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags.  */
1225   0,                            /* Leading underscore.  */
1226   ' ',                          /* AR_pad_char.  */
1227   16,                           /* AR_max_namelen.  */
1228   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1229   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1230   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Data.  */
1231   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1232   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1233   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Hdrs.  */
1234
1235   {
1236     _bfd_dummy_target,
1237     srec_object_p,              /* bfd_check_format.  */
1238     _bfd_dummy_target,
1239     _bfd_dummy_target,
1240   },
1241   {
1242     bfd_false,
1243     srec_mkobject,
1244     _bfd_generic_mkarchive,
1245     bfd_false,
1246   },
1247   {                             /* bfd_write_contents.  */
1248     bfd_false,
1249     srec_write_object_contents,
1250     _bfd_write_archive_contents,
1251     bfd_false,
1252   },
1253
1254   BFD_JUMP_TABLE_GENERIC (srec),
1255   BFD_JUMP_TABLE_COPY (_bfd_generic),
1256   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1257   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1258   BFD_JUMP_TABLE_SYMBOLS (srec),
1259   BFD_JUMP_TABLE_RELOCS (srec),
1260   BFD_JUMP_TABLE_WRITE (srec),
1261   BFD_JUMP_TABLE_LINK (srec),
1262   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1263
1264   NULL,
1265
1266   NULL
1267 };
1268
1269 const bfd_target symbolsrec_vec =
1270 {
1271   "symbolsrec",                 /* 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   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1284   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1285   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Data.  */
1286   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1287   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1288   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Headers.  */
1289
1290   {
1291     _bfd_dummy_target,
1292     symbolsrec_object_p,        /* bfd_check_format.  */
1293     _bfd_dummy_target,
1294     _bfd_dummy_target,
1295   },
1296   {
1297     bfd_false,
1298     srec_mkobject,
1299     _bfd_generic_mkarchive,
1300     bfd_false,
1301   },
1302   {                             /* bfd_write_contents.  */
1303     bfd_false,
1304     symbolsrec_write_object_contents,
1305     _bfd_write_archive_contents,
1306     bfd_false,
1307   },
1308
1309   BFD_JUMP_TABLE_GENERIC (srec),
1310   BFD_JUMP_TABLE_COPY (_bfd_generic),
1311   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1312   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1313   BFD_JUMP_TABLE_SYMBOLS (srec),
1314   BFD_JUMP_TABLE_RELOCS (srec),
1315   BFD_JUMP_TABLE_WRITE (srec),
1316   BFD_JUMP_TABLE_LINK (srec),
1317   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1318
1319   NULL,
1320
1321   NULL
1322 };