bfd/srec.c

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