bfd/srec.c

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