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