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