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