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