projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Add a flag to asection, linker_has_input, and use it to reliably
[deliverable/binutils-gdb.git] / bfd / srec.c
diff --git a/bfd/srec.c b/bfd/srec.c
index 6c6f8753bd786068d08e29b208c6ef8858e97879..43ac9a57c758c3a996ffcfbdf6df51e2eb63ad3f 100644 (file)
--- a/bfd/srec.c
+++ b/bfd/srec.c
@@ -1,5 +1,7 @@
 /* BFD back-end for s-record objects.
 /* BFD back-end for s-record objects.
-   Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
+   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+   2000
+   Free Software Foundation, Inc.
    Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
 
 This file is part of BFD, the Binary File Descriptor library.
    Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
 
 This file is part of BFD, the Binary File Descriptor library.
@@ -16,14 +18,14 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 /*
 SUBSECTION
        S-Record handling
 
 DESCRIPTION
 
 /*
 SUBSECTION
        S-Record handling
 
 DESCRIPTION
-       
+
        Ordinary S-Records cannot hold anything but addresses and
        data, so that's all that we implement.
 
        Ordinary S-Records cannot hold anything but addresses and
        data, so that's all that we implement.
 
@@ -41,10 +43,10 @@ DESCRIPTION
        up and output them when it's time to close the bfd.
 
        An s record looks like:
        up and output them when it's time to close the bfd.
 
        An s record looks like:
-       
+
 EXAMPLE
        S<type><length><address><data><checksum>
 EXAMPLE
        S<type><length><address><data><checksum>
-       
+
 DESCRIPTION
        Where
        o length
 DESCRIPTION
        Where
        o length
@@ -60,7 +62,7 @@ DESCRIPTION
        7) four byte address termination record
        8) three byte address termination record
        9) two byte address termination record
        7) four byte address termination record
        8) three byte address termination record
        9) two byte address termination record
-       
+
        o address
        is the start address of the data following, or in the case of
        a termination record, the start address of the image
        o address
        is the start address of the data following, or in the case of
        a termination record, the start address of the image
@@ -70,7 +72,6 @@ DESCRIPTION
        is the sum of all the raw byte data in the record, from the length
        upwards, modulo 256 and subtracted from 255.
 
        is the sum of all the raw byte data in the record, from the length
        upwards, modulo 256 and subtracted from 255.
 
-
 SUBSECTION
        Symbol S-Record handling
 
 SUBSECTION
        Symbol S-Record handling
 
@@ -100,544 +101,849 @@ EXAMPLE
 DESCRIPTION
        We allow symbols to be anywhere in the data stream - the module names
        are always ignored.
 DESCRIPTION
        We allow symbols to be anywhere in the data stream - the module names
        are always ignored.
-               
+
 */
 
 #include "bfd.h"
 #include "sysdep.h"
 #include "libbfd.h"
 */
 
 #include "bfd.h"
 #include "sysdep.h"
 #include "libbfd.h"
-
-/* Macros for converting between hex and binary */
+#include "libiberty.h"
+#include <ctype.h>
+
+static void srec_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
+static void srec_print_symbol
+ PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type));
+static void srec_init PARAMS ((void));
+static boolean srec_mkobject PARAMS ((bfd *));
+static int srec_get_byte PARAMS ((bfd *, boolean *));
+static void srec_bad_byte PARAMS ((bfd *, unsigned int, int, boolean));
+static boolean srec_scan PARAMS ((bfd *));
+static const bfd_target *srec_object_p PARAMS ((bfd *));
+static const bfd_target *symbolsrec_object_p PARAMS ((bfd *));
+static boolean srec_read_section PARAMS ((bfd *, asection *, bfd_byte *));
+
+static boolean srec_write_record PARAMS ((bfd *, int, bfd_vma,
+                                         const bfd_byte *,
+                                         const bfd_byte *));
+static boolean srec_write_header PARAMS ((bfd *));
+static boolean srec_write_symbols PARAMS ((bfd *));
+static boolean srec_new_symbol PARAMS ((bfd *, const char *, bfd_vma));
+static boolean srec_get_section_contents
+  PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
+static boolean srec_set_arch_mach
+  PARAMS ((bfd *, enum bfd_architecture, unsigned long));
+static boolean srec_set_section_contents
+  PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
+static boolean internal_srec_write_object_contents PARAMS ((bfd *, int));
+static boolean srec_write_object_contents PARAMS ((bfd *));
+static boolean symbolsrec_write_object_contents PARAMS ((bfd *));
+static int srec_sizeof_headers PARAMS ((bfd *, boolean));
+static asymbol *srec_make_empty_symbol PARAMS ((bfd *));
+static long srec_get_symtab_upper_bound PARAMS ((bfd *));
+static long srec_get_symtab PARAMS ((bfd *, asymbol **));
+
+/* Macros for converting between hex and binary.  */
 
 static CONST char digs[] = "0123456789ABCDEF";
 
 
 static CONST char digs[] = "0123456789ABCDEF";
 
-static char hex_value[1 + (unsigned char) ~0];
-
-#define NOT_HEX 20
-#define NIBBLE(x) hex_value[(unsigned char)(x)]
+#define NIBBLE(x) hex_value(x)
 #define HEX(buffer) ((NIBBLE((buffer)[0])<<4) + NIBBLE((buffer)[1]))
 #define TOHEX(d, x, ch) \
        d[1] = digs[(x) & 0xf]; \
        d[0] = digs[((x)>>4)&0xf]; \
        ch += ((x) & 0xff);
 #define HEX(buffer) ((NIBBLE((buffer)[0])<<4) + NIBBLE((buffer)[1]))
 #define TOHEX(d, x, ch) \
        d[1] = digs[(x) & 0xf]; \
        d[0] = digs[((x)>>4)&0xf]; \
        ch += ((x) & 0xff);
-#define        ISHEX(x)  (hex_value[(unsigned char)(x)] != NOT_HEX)
-
+#define        ISHEX(x)  hex_p(x)
 
 
+/* Initialize by filling in the hex conversion array.  */
 
 static void
 
 static void
-DEFUN_VOID (srec_init)
+srec_init ()
 {
 {
-  unsigned int i;
   static boolean inited = false;
 
   if (inited == false)
     {
   static boolean inited = false;
 
   if (inited == false)
     {
-
       inited = true;
       inited = true;
-
-      for (i = 0; i < sizeof (hex_value); i++)
-       {
-         hex_value[i] = NOT_HEX;
-       }
-
-      for (i = 0; i < 10; i++)
-       {
-         hex_value[i + '0'] = i;
-
-       }
-      for (i = 0; i < 6; i++)
-       {
-         hex_value[i + 'a'] = i + 10;
-         hex_value[i + 'A'] = i + 10;
-       }
+      hex_init ();
     }
 }
 
     }
 }
 
-
-/* The maximum number of bytes on a line is FF */
+/* The maximum number of bytes on a line is FF.  */
 #define MAXCHUNK 0xff
 #define MAXCHUNK 0xff
-/* The number of bytes we fit onto a line on output */
-#define CHUNK 21
 
 
-/* We cannot output our srecords as we see them, we have to glue them
-   together, this is done in this structure : */
+/* Default size for a CHUNK.  */
+#define DEFAULT_CHUNK 16
+
+/* The number of bytes we actually fit onto a line on output.
+   This variable can be modified by objcopy's --srec-len parameter.
+   For a 0x75 byte record you should set --srec-len=0x70.  */
+unsigned int Chunk = DEFAULT_CHUNK;
+
+/* The type of srec output (free or forced to S3).
+   This variable can be modified by objcopy's --srec-forceS3
+   parameter.  */
+boolean S3Forced = 0;
+
+/* When writing an S-record file, the S-records can not be output as
+   they are seen.  This structure is used to hold them in memory.  */
 
 struct srec_data_list_struct
 {
 
 struct srec_data_list_struct
 {
-  unsigned char *data;
+  struct srec_data_list_struct *next;
+  bfd_byte *data;
   bfd_vma where;
   bfd_size_type size;
   bfd_vma where;
   bfd_size_type size;
-  struct srec_data_list_struct *next;
+};
 
 
+typedef struct srec_data_list_struct srec_data_list_type;
+
+/* When scanning the S-record file, a linked list of srec_symbol
+   structures is built to represent the symbol table (if there is
+   one).  */
 
 
+struct srec_symbol
+{
+  struct srec_symbol *next;
+  const char *name;
+  bfd_vma val;
 };
 };
-typedef struct srec_data_list_struct srec_data_list_type;
 
 
+/* The S-record tdata information.  */
 
 typedef struct srec_data_struct
   {
     srec_data_list_type *head;
 
 typedef struct srec_data_struct
   {
     srec_data_list_type *head;
+    srec_data_list_type *tail;
     unsigned int type;
     unsigned int type;
-
-    int done_symbol_read;
-    int count;
-    asymbol *symbols;
-    char *strings;
-    int symbol_idx;
-    int string_size;
-    int string_idx;
+    struct srec_symbol *symbols;
+    struct srec_symbol *symtail;
+    asymbol *csymbols;
   }
 tdata_type;
 
   }
 tdata_type;
 
+static boolean srec_write_section PARAMS ((bfd *, tdata_type *,
+                                          srec_data_list_type *));
+static boolean srec_write_terminator PARAMS ((bfd *, tdata_type *));
 
 
-/*
-   called once per input S-Record, used to work out vma and size of data.
- */
-
-static bfd_vma low, high;
+/* Set up the S-record tdata information.  */
 
 
-/*ARGSUSED*/
-static void
-size_symbols (abfd, buf, len, val)
+static boolean
+srec_mkobject (abfd)
      bfd *abfd;
      bfd *abfd;
-     char *buf;
-     int len;
-     int val;
 {
 {
-  abfd->symcount++;
-  abfd->tdata.srec_data->string_size += len + 1;
-}
+  srec_init ();
 
 
-static void
-fillup_symbols (abfd, buf, len, val)
-     bfd *abfd;
-     char *buf;
-     int len;
-     int val;
-{
-  if (!abfd->tdata.srec_data->done_symbol_read)
+  if (abfd->tdata.srec_data == NULL)
     {
     {
-      asymbol *p;
-      if (abfd->tdata.srec_data->symbols == 0)
-       {
-         abfd->tdata.srec_data->symbols = (asymbol *) bfd_alloc (abfd, abfd->symcount * sizeof (asymbol));
-         abfd->tdata.srec_data->strings = (char *) bfd_alloc (abfd, abfd->tdata.srec_data->string_size);
-         if (!abfd->tdata.srec_data->symbols || !abfd->tdata.srec_data->strings)
-           {
-             bfd_set_error (bfd_error_no_memory);
-             abort ();         /* FIXME */
-           }
-         abfd->tdata.srec_data->symbol_idx = 0;
-         abfd->tdata.srec_data->string_idx = 0;
-       }
-
-      p = abfd->tdata.srec_data->symbols + abfd->tdata.srec_data->symbol_idx++;
-      p->the_bfd = abfd;
-      p->name = abfd->tdata.srec_data->strings + abfd->tdata.srec_data->string_idx;
-      memcpy ((char *) (p->name), buf, len + 1);
-      abfd->tdata.srec_data->string_idx += len + 1;
-      p->value = val;
-      p->flags = BSF_EXPORT | BSF_GLOBAL;
-      p->section = &bfd_abs_section;
-      p->udata = 0;
+      tdata_type *tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
+      if (tdata == NULL)
+       return false;
+      abfd->tdata.srec_data = tdata;
+      tdata->type = 1;
+      tdata->head = NULL;
+      tdata->tail = NULL;
+      tdata->symbols = NULL;
+      tdata->symtail = NULL;
+      tdata->csymbols = NULL;
     }
     }
-}
-/*ARGSUSED*/
-static void
-DEFUN (size_srec, (abfd, section, address, raw, length),
-       bfd * abfd AND
-       asection * section AND
-       bfd_vma address AND
-       bfd_byte * raw AND
-       unsigned int length)
-{
-  if (address < low)
-    low = address;
-  if (address + length > high)
-    high = address + length - 1;
+
+  return true;
 }
 
 }
 
+/* Read a byte from an S record file.  Set *ERRORPTR if an error
+   occurred.  Return EOF on error or end of file.  */
 
 
-/*
- called once per input S-Record, copies data from input into bfd_alloc'd area
- */
-
-/*ARGSUSED*/
-static void
-DEFUN (fillup, (abfd, section, address, raw, length),
-       bfd * abfd AND
-       asection * section AND
-       bfd_vma address AND
-       bfd_byte * raw AND
-       unsigned int length)
+static int
+srec_get_byte (abfd, errorptr)
+     bfd *abfd;
+     boolean *errorptr;
 {
 {
-  unsigned int i;
-  bfd_byte *dst =
-  (bfd_byte *) (section->used_by_bfd) + address - section->vma;
-  /* length -1 because we don't read in the checksum */
-  for (i = 0; i < length - 1; i++)
+  bfd_byte c;
+
+  if (bfd_read (&c, 1, 1, abfd) != 1)
     {
     {
-      *dst = HEX (raw);
-      dst++;
-      raw += 2;
+      if (bfd_get_error () != bfd_error_file_truncated)
+       *errorptr = true;
+      return EOF;
     }
     }
+
+  return (int) (c & 0xff);
 }
 
 }
 
-/* Pass over an S-Record file, calling one of the above functions on each
-   record.  */
+/* Report a problem in an S record file.  FIXME: This probably should
+   not call fprintf, but we really do need some mechanism for printing
+   error messages.  */
 
 
-static int 
-white (x)
-     char x;
-{
-  return (x == ' ' || x == '\t' || x == '\n' || x == '\r');
-}
-static int
-skipwhite (src, abfd)
-     char *src;
+static void
+srec_bad_byte (abfd, lineno, c, error)
      bfd *abfd;
      bfd *abfd;
+     unsigned int lineno;
+     int c;
+     boolean error;
 {
 {
-  int eof = 0;
-  while (white (*src) && !eof)
+  if (c == EOF)
     {
     {
-      eof = (boolean) (bfd_read (src, 1, 1, abfd) != 1);
+      if (! error)
+       bfd_set_error (bfd_error_file_truncated);
     }
     }
-  return eof;
-}
-
-static boolean
-DEFUN (srec_mkobject, (abfd),
-       bfd * abfd)
-{
-  if (abfd->tdata.srec_data == 0)
+  else
     {
     {
-      tdata_type *tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
-      if (!tdata)
+      char buf[10];
+
+      if (! isprint (c))
+       sprintf (buf, "\\%03o", (unsigned int) c);
+      else
        {
        {
-         bfd_set_error (bfd_error_no_memory);
-         return false;
+         buf[0] = c;
+         buf[1] = '\0';
        }
        }
-      abfd->tdata.srec_data = tdata;
-      tdata->type = 1;
-      tdata->head = (srec_data_list_type *) NULL;
+      (*_bfd_error_handler)
+       (_("%s:%d: Unexpected character `%s' in S-record file\n"),
+        bfd_get_filename (abfd), lineno, buf);
+      bfd_set_error (bfd_error_bad_value);
     }
     }
-  return true;
-
 }
 
 }
 
-static void 
-pass_over (abfd, func, symbolfunc, section)
+/* Add a new symbol found in an S-record file.  */
+
+static boolean
+srec_new_symbol (abfd, name, val)
      bfd *abfd;
      bfd *abfd;
-     void (*func) ();
-     void (*symbolfunc) ();
-     asection *section;
+     const char *name;
+     bfd_vma val;
 {
 {
-  unsigned int bytes_on_line;
-  boolean eof = false;
+  struct srec_symbol *n;
+
+  n = (struct srec_symbol *) bfd_alloc (abfd, sizeof (struct srec_symbol));
+  if (n == NULL)
+    return false;
+
+  n->name = name;
+  n->val = val;
+
+  if (abfd->tdata.srec_data->symbols == NULL)
+    abfd->tdata.srec_data->symbols = n;
+  else
+    abfd->tdata.srec_data->symtail->next = n;
+  abfd->tdata.srec_data->symtail = n;
+  n->next = NULL;
+
+  ++abfd->symcount;
+
+  return true;
+}
+
+/* Read the S record file and turn it into sections.  We create a new
+   section for each contiguous set of bytes.  */
 
 
-  srec_mkobject (abfd);
-  /* To the front of the file */
-  bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
-  while (eof == false)
+static boolean
+srec_scan (abfd)
+     bfd *abfd;
+{
+  int c;
+  unsigned int lineno = 1;
+  boolean error = false;
+  bfd_byte *buf = NULL;
+  size_t bufsize = 0;
+  asection *sec = NULL;
+  char *symbuf = NULL;
+
+  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
+    goto error_return;
+
+  while ((c = srec_get_byte (abfd, &error)) != EOF)
     {
     {
-      char buffer[MAXCHUNK];
-      char *src = buffer;
-      char type;
-      bfd_vma address = 0;
-
-      /* Find first 'S' or $ */
-      eof = (boolean) (bfd_read (src, 1, 1, abfd) != 1);
-      switch (*src)
+      /* We only build sections from contiguous S-records, so if this
+         is not an S-record, then stop building a section.  */
+      if (c != 'S' && c != '\r' && c != '\n')
+       sec = NULL;
+
+      switch (c)
        {
        default:
        {
        default:
-         if (eof)
-           return;
+         srec_bad_byte (abfd, lineno, c, error);
+         goto error_return;
+
+       case '\n':
+         ++lineno;
+         break;
+
+       case '\r':
          break;
 
        case '$':
          break;
 
        case '$':
-         /* Inside a symbol definition - just ignore the module name */
-         while (*src != '\n' && !eof)
+         /* Starting a module name, which we ignore.  */
+         while ((c = srec_get_byte (abfd, &error)) != '\n'
+                && c != EOF)
+           ;
+         if (c == EOF)
            {
            {
-             eof = (boolean) (bfd_read (src, 1, 1, abfd) != 1);
+             srec_bad_byte (abfd, lineno, c, error);
+             goto error_return;
            }
            }
+
+         ++lineno;
+
          break;
 
        case ' ':
          break;
 
        case ' ':
-         /* spaces - maybe just before a symbol */
-         while (*src != '\n' && *src != '\r' && white (*src))
+         do
+           {
+             unsigned int alc;
+             char *p, *symname;
+             bfd_vma symval;
+
+             /* Starting a symbol definition.  */
+             while ((c = srec_get_byte (abfd, &error)) != EOF
+                    && (c == ' ' || c == '\t'))
+               ;
+
+             if (c == '\n' || c == '\r')
+               break;
+
+             if (c == EOF)
+               {
+                 srec_bad_byte (abfd, lineno, c, error);
+                 goto error_return;
+               }
+
+             alc = 10;
+             symbuf = (char *) bfd_malloc (alc + 1);
+             if (symbuf == NULL)
+               goto error_return;
+
+             p = symbuf;
+
+             *p++ = c;
+             while ((c = srec_get_byte (abfd, &error)) != EOF
+                    && ! isspace (c))
+               {
+                 if ((unsigned int) (p - symbuf) >= alc)
+                   {
+                     char *n;
+
+                     alc *= 2;
+                     n = (char *) bfd_realloc (symbuf, alc + 1);
+                     if (n == NULL)
+                       goto error_return;
+                     p = n + (p - symbuf);
+                     symbuf = n;
+                   }
+
+                 *p++ = c;
+               }
+
+             if (c == EOF)
+               {
+                 srec_bad_byte (abfd, lineno, c, error);
+                 goto error_return;
+               }
+
+             *p++ = '\0';
+             symname = bfd_alloc (abfd, p - symbuf);
+             if (symname == NULL)
+               goto error_return;
+             strcpy (symname, symbuf);
+             free (symbuf);
+             symbuf = NULL;
+
+             while ((c = srec_get_byte (abfd, &error)) != EOF
+                    && (c == ' ' || c == '\t'))
+               ;
+             if (c == EOF)
+               {
+                 srec_bad_byte (abfd, lineno, c, error);
+                 goto error_return;
+               }
+
+             /* Skip a dollar sign before the hex value.  */
+             if (c == '$')
+               {
+                 c = srec_get_byte (abfd, &error);
+                 if (c == EOF)
+                   {
+                     srec_bad_byte (abfd, lineno, c, error);
+                     goto error_return;
+                   }
+               }
+
+             symval = 0;
+             while (ISHEX (c))
+               {
+                 symval <<= 4;
+                 symval += NIBBLE (c);
+                 c = srec_get_byte (abfd, &error);
+               }
+
+             if (! srec_new_symbol (abfd, symname, symval))
+               goto error_return;
+           }
+         while (c == ' ' || c == '\t')
+           ;
+
+         if (c == '\n')
+           ++lineno;
+         else if (c != '\r')
            {
            {
-             eof = skipwhite (src, abfd);
+             srec_bad_byte (abfd, lineno, c, error);
+             goto error_return;
+           }
+
+         break;
 
 
+       case 'S':
+         {
+           file_ptr pos;
+           char hdr[3];
+           unsigned int bytes;
+           bfd_vma address;
+           bfd_byte *data;
+
+           /* Starting an S-record.  */
+
+           pos = bfd_tell (abfd) - 1;
+
+           if (bfd_read (hdr, 1, 3, abfd) != 3)
+             goto error_return;
+
+           if (! ISHEX (hdr[1]) || ! ISHEX (hdr[2]))
              {
              {
-               int val = 0;
-               int slen = 0;
-               char symbol[MAXCHUNK];
+               if (! ISHEX (hdr[1]))
+                 c = hdr[1];
+               else
+                 c = hdr[2];
+               srec_bad_byte (abfd, lineno, c, error);
+               goto error_return;
+             }
+
+           bytes = HEX (hdr + 1);
+           if (bytes * 2 > bufsize)
+             {
+               if (buf != NULL)
+                 free (buf);
+               buf = (bfd_byte *) bfd_malloc (bytes * 2);
+               if (buf == NULL)
+                 goto error_return;
+               bufsize = bytes * 2;
+             }
 
 
-               /* get the symbol part */
-               while (!eof && !white (*src) && slen < MAXCHUNK)
+           if (bfd_read (buf, 1, bytes * 2, abfd) != bytes * 2)
+             goto error_return;
+
+           /* Ignore the checksum byte.  */
+           --bytes;
+
+           address = 0;
+           data = buf;
+           switch (hdr[0])
+             {
+             case '0':
+             case '5':
+               /* Prologue--ignore the file name, but stop building a
+                   section at this point.  */
+               sec = NULL;
+               break;
+
+             case '3':
+               address = HEX (data);
+               data += 2;
+               --bytes;
+               /* Fall through.  */
+             case '2':
+               address = (address << 8) | HEX (data);
+               data += 2;
+               --bytes;
+               /* Fall through.  */
+             case '1':
+               address = (address << 8) | HEX (data);
+               data += 2;
+               address = (address << 8) | HEX (data);
+               data += 2;
+               bytes -= 2;
+
+               if (sec != NULL
+                   && sec->vma + sec->_raw_size == address)
                  {
                  {
-                   symbol[slen++] = *src;
-                   eof = (boolean) (bfd_read (src, 1, 1, abfd) != 1);
+                   /* This data goes at the end of the section we are
+                       currently building.  */
+                   sec->_raw_size += bytes;
                  }
                  }
-               symbol[slen] = 0;
-               eof = skipwhite (src, abfd);
-               /* skip the $ for the hex value */
-               if (*src == '$')
+               else
                  {
                  {
-                   eof = (boolean) (bfd_read (src, 1, 1, abfd) != 1);
+                   char secbuf[20];
+                   char *secname;
+
+                   sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
+                   secname = (char *) bfd_alloc (abfd, strlen (secbuf) + 1);
+                   strcpy (secname, secbuf);
+                   sec = bfd_make_section (abfd, secname);
+                   if (sec == NULL)
+                     goto error_return;
+                   sec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
+                   sec->vma = address;
+                   sec->lma = address;
+                   sec->_raw_size = bytes;
+                   sec->filepos = pos;
                  }
 
                  }
 
-               /* Scan off the hex number */
-               while (isxdigit (*src))
-                 {
-                   val *= 16;
-                   if (isdigit (*src))
-                     val += *src - '0';
-                   else if (isupper (*src))
-                     {
-                       val += *src - 'A' + 10;
-                     }
-                   else
-                     {
-                       val += *src - 'a' + 10;
-                     }
-                   eof = (boolean) (bfd_read (src, 1, 1, abfd) != 1);
-                 }
-               symbolfunc (abfd, symbol, slen, val);
+               break;
+
+             case '7':
+               address = HEX (data);
+               data += 2;
+               /* Fall through.  */
+             case '8':
+               address = (address << 8) | HEX (data);
+               data += 2;
+               /* Fall through.  */
+             case '9':
+               address = (address << 8) | HEX (data);
+               data += 2;
+               address = (address << 8) | HEX (data);
+               data += 2;
+
+               /* This is a termination record.  */
+               abfd->start_address = address;
+
+               if (buf != NULL)
+                 free (buf);
+
+               return true;
              }
              }
-           }
+         }
          break;
          break;
-       case 'S':
-         src++;
+       }
+    }
 
 
-         /* Fetch the type and the length */
-         bfd_read (src, 1, 3, abfd);
+  if (error)
+    goto error_return;
 
 
-         type = *src++;
+  if (buf != NULL)
+    free (buf);
 
 
-         if (!ISHEX (src[0]) || !ISHEX (src[1]))
-           break;
+  return true;
 
 
-         bytes_on_line = HEX (src);
+ error_return:
+  if (symbuf != NULL)
+    free (symbuf);
+  if (buf != NULL)
+    free (buf);
+  return false;
+}
 
 
-         if (bytes_on_line > MAXCHUNK / 2)
-           break;
-         src += 2;
+/* Check whether an existing file is an S-record file.  */
 
 
-         bfd_read (src, 1, bytes_on_line * 2, abfd);
+static const bfd_target *
+srec_object_p (abfd)
+     bfd *abfd;
+{
+  bfd_byte b[4];
 
 
-         switch (type)
-           {
-           case '0':
-           case '5':
-             /* Prologue - ignore */
-             break;
-           case '3':
-             address = HEX (src);
-             src += 2;
-             bytes_on_line--;
-
-           case '2':
-             address = HEX (src) | (address << 8);
-             src += 2;
-             bytes_on_line--;
-           case '1':
-             address = HEX (src) | (address << 8);
-             src += 2;
-             address = HEX (src) | (address << 8);
-             src += 2;
-             bytes_on_line -= 2;
-             func (abfd, section, address, src, bytes_on_line);
-             break;
-           default:
-             return;
-           }
-       }
+  srec_init ();
+
+  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
+      || bfd_read (b, 1, 4, abfd) != 4)
+    return NULL;
+
+  if (b[0] != 'S' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
+    {
+      bfd_set_error (bfd_error_wrong_format);
+      return NULL;
     }
 
     }
 
-}
+  if (! srec_mkobject (abfd)
+      || ! srec_scan (abfd))
+    return NULL;
 
 
-static bfd_target *
-object_p (abfd)
-     bfd *abfd;
-{
-  asection *section;
-  /* We create one section called .text for all the contents,
-     and allocate enough room for the entire file.  */
-
-  section = bfd_make_section (abfd, ".text");
-  section->_raw_size = 0;
-  section->vma = 0xffffffff;
-  low = 0xffffffff;
-  high = 0;
-  pass_over (abfd, size_srec, size_symbols, section);
-  section->_raw_size = high - low;
-  section->vma = low;
-  section->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
-
-  if (abfd->symcount)
+  if (abfd->symcount > 0)
     abfd->flags |= HAS_SYMS;
     abfd->flags |= HAS_SYMS;
+
   return abfd->xvec;
 }
 
   return abfd->xvec;
 }
 
-static bfd_target *
-DEFUN (srec_object_p, (abfd),
-       bfd * abfd)
+/* Check whether an existing file is an S-record file with symbols.  */
+
+static const bfd_target *
+symbolsrec_object_p (abfd)
+     bfd *abfd;
 {
 {
-  char b[4];
+  char b[2];
 
   srec_init ();
 
 
   srec_init ();
 
-  bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
-  bfd_read (b, 1, 4, abfd);
+  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
+      || bfd_read (b, 1, 2, abfd) != 2)
+    return NULL;
 
 
-  if (b[0] != 'S' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
-    return (bfd_target *) NULL;
+  if (b[0] != '$' || b[1] != '$')
+    {
+      bfd_set_error (bfd_error_wrong_format);
+      return NULL;
+    }
+
+  if (! srec_mkobject (abfd)
+      || ! srec_scan (abfd))
+    return NULL;
 
 
-  /* We create one section called .text for all the contents,
-     and allocate enough room for the entire file.  */
+  if (abfd->symcount > 0)
+    abfd->flags |= HAS_SYMS;
 
 
-  return object_p (abfd);
+  return abfd->xvec;
 }
 
 }
 
+/* Read in the contents of a section in an S-record file.  */
 
 
-static bfd_target *
-DEFUN (symbolsrec_object_p, (abfd),
-       bfd * abfd)
+static boolean
+srec_read_section (abfd, section, contents)
+     bfd *abfd;
+     asection *section;
+     bfd_byte *contents;
 {
 {
-  char b[4];
+  int c;
+  bfd_size_type sofar = 0;
+  boolean error = false;
+  bfd_byte *buf = NULL;
+  size_t bufsize = 0;
 
 
-  srec_init ();
+  if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
+    goto error_return;
 
 
-  bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
-  bfd_read (b, 1, 4, abfd);
+  while ((c = srec_get_byte (abfd, &error)) != EOF)
+    {
+      bfd_byte hdr[3];
+      unsigned int bytes;
+      bfd_vma address;
+      bfd_byte *data;
 
 
-  if (b[0] != '$' || b[1] != '$')
-    return (bfd_target *) NULL;
+      if (c == '\r' || c == '\n')
+       continue;
+
+      /* This is called after srec_scan has already been called, so we
+         ought to know the exact format.  */
+      BFD_ASSERT (c == 'S');
+
+      if (bfd_read (hdr, 1, 3, abfd) != 3)
+       goto error_return;
+
+      BFD_ASSERT (ISHEX (hdr[1]) && ISHEX (hdr[2]));
+
+      bytes = HEX (hdr + 1);
+
+      if (bytes * 2 > bufsize)
+       {
+         if (buf != NULL)
+           free (buf);
+         buf = (bfd_byte *) bfd_malloc (bytes * 2);
+         if (buf == NULL)
+           goto error_return;
+         bufsize = bytes * 2;
+       }
+
+      if (bfd_read (buf, 1, bytes * 2, abfd) != bytes * 2)
+       goto error_return;
+
+      address = 0;
+      data = buf;
+      switch (hdr[0])
+       {
+       default:
+         BFD_ASSERT (sofar == section->_raw_size);
+         if (buf != NULL)
+           free (buf);
+         return true;
+
+       case '3':
+         address = HEX (data);
+         data += 2;
+         --bytes;
+         /* Fall through.  */
+       case '2':
+         address = (address << 8) | HEX (data);
+         data += 2;
+         --bytes;
+         /* Fall through.  */
+       case '1':
+         address = (address << 8) | HEX (data);
+         data += 2;
+         address = (address << 8) | HEX (data);
+         data += 2;
+         bytes -= 2;
+
+         if (address != section->vma + sofar)
+           {
+             /* We've come to the end of this section.  */
+             BFD_ASSERT (sofar == section->_raw_size);
+             if (buf != NULL)
+               free (buf);
+             return true;
+           }
+
+         /* Don't consider checksum.  */
+         --bytes;
+
+         while (bytes-- != 0)
+           {
+             contents[sofar] = HEX (data);
+             data += 2;
+             ++sofar;
+           }
+
+         break;
+       }
+    }
+
+  if (error)
+    goto error_return;
+
+  BFD_ASSERT (sofar == section->_raw_size);
 
 
-  return object_p (abfd);
+  if (buf != NULL)
+    free (buf);
+
+  return true;
+
+ error_return:
+  if (buf != NULL)
+    free (buf);
+  return false;
 }
 
 }
 
+/* Get the contents of a section in an S-record file.  */
 
 static boolean
 
 static boolean
-DEFUN (srec_get_section_contents, (abfd, section, location, offset, count),
-       bfd * abfd AND
-       asection * section AND
-       PTR location AND
-       file_ptr offset AND
-       bfd_size_type count)
+srec_get_section_contents (abfd, section, location, offset, count)
+     bfd *abfd;
+     asection *section;
+     PTR location;
+     file_ptr offset;
+     bfd_size_type count;
 {
 {
-  if (section->used_by_bfd == (PTR) NULL)
+  if (section->used_by_bfd == NULL)
     {
     {
-      section->used_by_bfd = (PTR) bfd_alloc (abfd, section->_raw_size);
-      if (!section->used_by_bfd)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         return false;
-       }
+      section->used_by_bfd = bfd_alloc (abfd, section->_raw_size);
+      if (section->used_by_bfd == NULL
+         && section->_raw_size != 0)
+       return false;
 
 
-      pass_over (abfd, fillup, fillup_symbols, section);
+      if (! srec_read_section (abfd, section, section->used_by_bfd))
+       return false;
     }
     }
-  memcpy ((PTR) location,
-                (PTR) ((char *) (section->used_by_bfd) + offset),
-                count);
+
+  memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
+         (size_t) count);
+
   return true;
 }
 
   return true;
 }
 
+/* Set the architecture.  We accept an unknown architecture here.  */
 
 
-
-boolean
-DEFUN (srec_set_arch_mach, (abfd, arch, machine),
-       bfd * abfd AND
-       enum bfd_architecture arch AND
-       unsigned long machine)
+static boolean
+srec_set_arch_mach (abfd, arch, mach)
+     bfd *abfd;
+     enum bfd_architecture arch;
+     unsigned long mach;
 {
 {
-  return bfd_default_set_arch_mach (abfd, arch, machine);
+  if (arch == bfd_arch_unknown)
+    {
+      abfd->arch_info = &bfd_default_arch_struct;
+      return true;
+    }
+  return bfd_default_set_arch_mach (abfd, arch, mach);
 }
 
 }
 
-
-/* we have to save up all the Srecords for a splurge before output,
-   also remember   */
+/* We have to save up all the Srecords for a splurge before output.  */
 
 static boolean
 
 static boolean
-DEFUN (srec_set_section_contents, (abfd, section, location, offset, bytes_to_do),
-       bfd * abfd AND
-       sec_ptr section AND
-       PTR location AND
-       file_ptr offset AND
-       bfd_size_type bytes_to_do)
+srec_set_section_contents (abfd, section, location, offset, bytes_to_do)
+     bfd *abfd;
+     sec_ptr section;
+     PTR location;
+     file_ptr offset;
+     bfd_size_type bytes_to_do;
 {
   tdata_type *tdata = abfd->tdata.srec_data;
 {
   tdata_type *tdata = abfd->tdata.srec_data;
-  srec_data_list_type *entry = (srec_data_list_type *)
-    bfd_alloc (abfd, sizeof (srec_data_list_type));
+  register srec_data_list_type *entry;
 
 
-  if (!entry)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return false;
-    }
+  entry = ((srec_data_list_type *)
+          bfd_alloc (abfd, sizeof (srec_data_list_type)));
+  if (entry == NULL)
+    return false;
 
 
-  if ((section->flags & SEC_ALLOC)
+  if (bytes_to_do
+      && (section->flags & SEC_ALLOC)
       && (section->flags & SEC_LOAD))
     {
       && (section->flags & SEC_LOAD))
     {
-      unsigned char *data = (unsigned char *) bfd_alloc (abfd, bytes_to_do);
-      if (!data)
-       {
-         bfd_set_error (bfd_error_no_memory);
-         return false;
-       }
-      memcpy ((PTR) data, location, bytes_to_do);
+      bfd_byte *data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do);
+      if (data == NULL)
+       return false;
+      memcpy ((PTR) data, location, (size_t) bytes_to_do);
+
+      /* Ff S3Forced is true then always select S3 records,
+        regardless of the siez of the addresses.  */
+      if (S3Forced)
+       tdata->type = 3;
+      else if ((section->lma + offset + bytes_to_do - 1) <= 0xffff)
+       ;  /* The default, S1, is OK.  */
+      else if ((section->lma + offset + bytes_to_do - 1) <= 0xffffff
+              && tdata->type <= 2)
+       tdata->type = 2;
+      else
+       tdata->type = 3;
 
 
-      if ((section->lma + offset + bytes_to_do) <= 0xffff)
-       {
+      entry->data = data;
+      entry->where = section->lma + offset;
+      entry->size = bytes_to_do;
 
 
-       }
-      else if ((section->lma + offset + bytes_to_do) <= 0xffffff
-              && tdata->type < 2)
+      /* Sort the records by address.  Optimize for the common case of
+         adding a record to the end of the list.  */
+      if (tdata->tail != NULL
+         && entry->where >= tdata->tail->where)
        {
        {
-         tdata->type = 2;
+         tdata->tail->next = entry;
+         entry->next = NULL;
+         tdata->tail = entry;
        }
       else
        {
        }
       else
        {
-         tdata->type = 3;
+         register srec_data_list_type **look;
+
+         for (look = &tdata->head;
+              *look != NULL && (*look)->where < entry->where;
+              look = &(*look)->next)
+           ;
+         entry->next = *look;
+         *look = entry;
+         if (entry->next == NULL)
+           tdata->tail = entry;
        }
        }
-
-      entry->data = data;
-      entry->where = section->lma + offset;
-      entry->size = bytes_to_do;
-      entry->next = tdata->head;
-      tdata->head = entry;
     }
   return true;
 }
 
 /* Write a record of type, of the supplied number of bytes. The
    supplied bytes and length don't have a checksum. That's worked out
     }
   return true;
 }
 
 /* Write a record of type, of the supplied number of bytes. The
    supplied bytes and length don't have a checksum. That's worked out
-   here
-*/
-static
-void 
-DEFUN (srec_write_record, (abfd, type, address, data, end),
-       bfd * abfd AND
-       char type AND
-       bfd_vma address AND
-       CONST unsigned char *data AND
-       CONST unsigned char *end)
+   here.  */
 
 
+static boolean
+srec_write_record (abfd, type, address, data, end)
+     bfd *abfd;
+     int type;
+     bfd_vma address;
+     const bfd_byte *data;
+     const bfd_byte *end;
 {
   char buffer[MAXCHUNK];
 {
   char buffer[MAXCHUNK];
-
   unsigned int check_sum = 0;
   unsigned int check_sum = 0;
-  CONST unsigned char *src = data;
+  CONST bfd_byte *src = data;
   char *dst = buffer;
   char *length;
   char *dst = buffer;
   char *length;
-
+  bfd_size_type wrlen;
 
   *dst++ = 'S';
   *dst++ = '0' + type;
 
   length = dst;
 
   *dst++ = 'S';
   *dst++ = '0' + type;
 
   length = dst;
-  dst += 2;                    /* leave room for dst*/
+  dst += 2;                    /* Leave room for dst.  */
 
   switch (type)
     {
 
   switch (type)
     {
@@ -665,7 +971,7 @@ DEFUN (srec_write_record, (abfd, type, address, data, end),
       dst += 2;
     }
 
       dst += 2;
     }
 
-  /* Fill in the length */
+  /* Fill in the length.  */
   TOHEX (length, (dst - length) / 2, check_sum);
   check_sum &= 0xff;
   check_sum = 255 - check_sum;
   TOHEX (length, (dst - length) / 2, check_sum);
   check_sum &= 0xff;
   check_sum = 255 - check_sum;
@@ -674,116 +980,98 @@ DEFUN (srec_write_record, (abfd, type, address, data, end),
 
   *dst++ = '\r';
   *dst++ = '\n';
 
   *dst++ = '\r';
   *dst++ = '\n';
-  bfd_write ((PTR) buffer, 1, dst - buffer, abfd);
+  wrlen = dst - buffer;
+  if (bfd_write ((PTR) buffer, 1, wrlen, abfd) != wrlen)
+    return false;
+  return true;
 }
 
 }
 
-
-
-static void
-DEFUN (srec_write_header, (abfd),
-       bfd * abfd)
+static boolean
+srec_write_header (abfd)
+     bfd *abfd;
 {
 {
-  unsigned char buffer[MAXCHUNK];
-  unsigned char *dst = buffer;
+  bfd_byte buffer[MAXCHUNK];
+  bfd_byte *dst = buffer;
   unsigned int i;
 
   unsigned int i;
 
-  /* I'll put an arbitary 40 char limit on header size */
+  /* I'll put an arbitary 40 char limit on header size.  */
   for (i = 0; i < 40 && abfd->filename[i]; i++)
   for (i = 0; i < 40 && abfd->filename[i]; i++)
-    {
-      *dst++ = abfd->filename[i];
-    }
-  srec_write_record (abfd, 0, 0, buffer, dst);
+    *dst++ = abfd->filename[i];
+
+  return srec_write_record (abfd, 0, 0, buffer, dst);
 }
 
 }
 
-static void
-DEFUN (srec_write_section, (abfd, tdata, list),
-       bfd * abfd AND
-       tdata_type * tdata AND
-       srec_data_list_type * list)
+static boolean
+srec_write_section (abfd, tdata, list)
+     bfd *abfd;
+     tdata_type *tdata;
+     srec_data_list_type *list;
 {
 {
-  unsigned int bytes_written = 0;
-  unsigned char *location = list->data;
+  unsigned int octets_written = 0;
+  bfd_byte *location = list->data;
 
 
-  while (bytes_written < list->size)
+  while (octets_written < list->size)
     {
       bfd_vma address;
     {
       bfd_vma address;
+      unsigned int octets_this_chunk = list->size - octets_written;
 
 
-      unsigned int bytes_this_chunk = list->size - bytes_written;
+      if (octets_this_chunk > Chunk)
+       octets_this_chunk = Chunk;
 
 
-      if (bytes_this_chunk > CHUNK)
-       {
-         bytes_this_chunk = CHUNK;
-       }
+      address = list->where + octets_written / bfd_octets_per_byte (abfd);
 
 
-      address = list->where + bytes_written;
+      if (! srec_write_record (abfd,
+                              tdata->type,
+                              address,
+                              location,
+                              location + octets_this_chunk))
+       return false;
 
 
-      srec_write_record (abfd,
-                        tdata->type,
-                        address,
-                        location,
-                        location + bytes_this_chunk);
-
-      bytes_written += bytes_this_chunk;
-      location += bytes_this_chunk;
+      octets_written += octets_this_chunk;
+      location += octets_this_chunk;
     }
 
     }
 
+  return true;
 }
 
 }
 
-static void
-DEFUN (srec_write_terminator, (abfd, tdata),
-       bfd * abfd AND
-       tdata_type * tdata)
+static boolean
+srec_write_terminator (abfd, tdata)
+     bfd *abfd;
+     tdata_type *tdata;
 {
 {
-  unsigned char buffer[2];
+  bfd_byte buffer[2];
 
 
-  srec_write_record (abfd, 10 - tdata->type,
-                    abfd->start_address, buffer, buffer);
+  return srec_write_record (abfd, 10 - tdata->type,
+                           abfd->start_address, buffer, buffer);
 }
 
 }
 
-
-
-static void
+static boolean
 srec_write_symbols (abfd)
      bfd *abfd;
 {
   char buffer[MAXCHUNK];
 srec_write_symbols (abfd)
      bfd *abfd;
 {
   char buffer[MAXCHUNK];
-  /* Dump out the symbols of a bfd */
+  /* Dump out the symbols of a bfd.  */
   int i;
   int i;
-  int len = bfd_get_symcount (abfd);
+  int count = bfd_get_symcount (abfd);
 
 
-  if (len)
+  if (count)
     {
     {
+      size_t len;
       asymbol **table = bfd_get_outsymbols (abfd);
       sprintf (buffer, "$$ %s\r\n", abfd->filename);
 
       asymbol **table = bfd_get_outsymbols (abfd);
       sprintf (buffer, "$$ %s\r\n", abfd->filename);
 
-      bfd_write (buffer, strlen (buffer), 1, abfd);
+      len = strlen (buffer);
+      if (bfd_write (buffer, len, 1, abfd) != len)
+       return false;
 
 
-      for (i = 0; i < len; i++)
+      for (i = 0; i < count; i++)
        {
          asymbol *s = table[i];
        {
          asymbol *s = table[i];
-#if 0
-         int len = strlen (s->name);
-
-         /* If this symbol has a .[ocs] in it, it's probably a file name
-        and we'll output that as the module name */
-
-         if (len > 3 && s->name[len - 2] == '.')
-           {
-             int l;
-             sprintf (buffer, "$$ %s\r\n", s->name);
-             l = strlen (buffer);
-             bfd_write (buffer, l, 1, abfd);
-           }
-         else
-#endif
-           if (s->flags & (BSF_GLOBAL | BSF_LOCAL)
-               && (s->flags & BSF_DEBUGGING) == 0
-               && s->name[0] != '.'
-               && s->name[0] != 't')
+         if (! bfd_is_local_label (abfd, s)
+             && (s->flags & BSF_DEBUGGING) == 0)
            {
            {
-             /* Just dump out non debug symbols */
-
-             int l;
+             /* Just dump out non debug symbols.  */
+             bfd_size_type l;
              char buf2[40], *p;
 
              sprintf_vma (buf2,
              char buf2[40], *p;
 
              sprintf_vma (buf2,
@@ -794,12 +1082,17 @@ srec_write_symbols (abfd)
                p++;
              sprintf (buffer, "  %s $%s\r\n", s->name, p);
              l = strlen (buffer);
                p++;
              sprintf (buffer, "  %s $%s\r\n", s->name, p);
              l = strlen (buffer);
-             bfd_write (buffer, l, 1, abfd);
+             if (bfd_write (buffer, l, 1, abfd) != l)
+               return false;
            }
        }
       sprintf (buffer, "$$ \r\n");
            }
        }
       sprintf (buffer, "$$ \r\n");
-      bfd_write (buffer, strlen (buffer), 1, abfd);
+      len = strlen (buffer);
+      if (bfd_write (buffer, len, 1, abfd) != len)
+       return false;
     }
     }
+
+  return true;
 }
 
 static boolean
 }
 
 static boolean
@@ -811,20 +1104,24 @@ internal_srec_write_object_contents (abfd, symbols)
   srec_data_list_type *list;
 
   if (symbols)
   srec_data_list_type *list;
 
   if (symbols)
-    srec_write_symbols (abfd);
+    {
+      if (! srec_write_symbols (abfd))
+       return false;
+    }
 
 
-  srec_write_header (abfd);
+  if (! srec_write_header (abfd))
+    return false;
 
 
-  /* Now wander though all the sections provided and output them */
+  /* Now wander though all the sections provided and output them.  */
   list = tdata->head;
 
   while (list != (srec_data_list_type *) NULL)
     {
   list = tdata->head;
 
   while (list != (srec_data_list_type *) NULL)
     {
-      srec_write_section (abfd, tdata, list);
+      if (! srec_write_section (abfd, tdata, list))
+       return false;
       list = list->next;
     }
       list = list->next;
     }
-  srec_write_terminator (abfd, tdata);
-  return true;
+  return srec_write_terminator (abfd, tdata);
 }
 
 static boolean
 }
 
 static boolean
@@ -841,18 +1138,17 @@ symbolsrec_write_object_contents (abfd)
   return internal_srec_write_object_contents (abfd, 1);
 }
 
   return internal_srec_write_object_contents (abfd, 1);
 }
 
-/*ARGSUSED*/
 static int
 static int
-DEFUN (srec_sizeof_headers, (abfd, exec),
-       bfd * abfd AND
-       boolean exec)
+srec_sizeof_headers (abfd, exec)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     boolean exec ATTRIBUTE_UNUSED;
 {
   return 0;
 }
 
 static asymbol *
 {
   return 0;
 }
 
 static asymbol *
-DEFUN (srec_make_empty_symbol, (abfd),
-       bfd * abfd)
+srec_make_empty_symbol (abfd)
+     bfd *abfd;
 {
   asymbol *new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
   if (new)
 {
   asymbol *new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
   if (new)
@@ -860,47 +1156,72 @@ DEFUN (srec_make_empty_symbol, (abfd),
   return new;
 }
 
   return new;
 }
 
-static unsigned int
+/* Return the amount of memory needed to read the symbol table.  */
+
+static long
 srec_get_symtab_upper_bound (abfd)
      bfd *abfd;
 {
 srec_get_symtab_upper_bound (abfd)
      bfd *abfd;
 {
-  /* Read in all the info */
-  srec_get_section_contents (abfd, abfd->sections, 0, 0, 0);
-  return (bfd_get_symcount (abfd) + 1) * (sizeof (asymbol *));
+  return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *);
 }
 
 }
 
-static unsigned int
-DEFUN (srec_get_symtab, (abfd, alocation),
-       bfd * abfd AND
-       asymbol ** alocation)
+/* Return the symbol table.  */
+
+static long
+srec_get_symtab (abfd, alocation)
+     bfd *abfd;
+     asymbol **alocation;
 {
 {
-  int lim = abfd->symcount;
-  int i;
-  for (i = 0; i < lim; i++)
+  unsigned int symcount = bfd_get_symcount (abfd);
+  asymbol *csymbols;
+  unsigned int i;
+
+  csymbols = abfd->tdata.srec_data->csymbols;
+  if (csymbols == NULL)
     {
     {
-      alocation[i] = abfd->tdata.srec_data->symbols + i;
+      asymbol *c;
+      struct srec_symbol *s;
+
+      csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));
+      if (csymbols == NULL && symcount != 0)
+       return false;
+      abfd->tdata.srec_data->csymbols = csymbols;
+
+      for (s = abfd->tdata.srec_data->symbols, c = csymbols;
+          s != NULL;
+          s = s->next, ++c)
+       {
+         c->the_bfd = abfd;
+         c->name = s->name;
+         c->value = s->val;
+         c->flags = BSF_GLOBAL;
+         c->section = bfd_abs_section_ptr;
+         c->udata.p = NULL;
+       }
     }
     }
-  alocation[i] = 0;
-  return lim;
+
+  for (i = 0; i < symcount; i++)
+    *alocation++ = csymbols++;
+  *alocation = NULL;
+
+  return symcount;
 }
 
 }
 
-/*ARGSUSED*/
-void
-DEFUN (srec_get_symbol_info, (ignore_abfd, symbol, ret),
-       bfd * ignore_abfd AND
-       asymbol * symbol AND
-       symbol_info * ret)
+static void
+srec_get_symbol_info (ignore_abfd, symbol, ret)
+     bfd *ignore_abfd ATTRIBUTE_UNUSED;
+     asymbol *symbol;
+     symbol_info *ret;
 {
   bfd_symbol_info (symbol, ret);
 }
 
 {
   bfd_symbol_info (symbol, ret);
 }
 
-/*ARGSUSED*/
-void
-DEFUN (srec_print_symbol, (ignore_abfd, afile, symbol, how),
-       bfd * ignore_abfd AND
-       PTR afile AND
-       asymbol * symbol AND
-       bfd_print_symbol_type how)
+static void
+srec_print_symbol (ignore_abfd, afile, symbol, how)
+     bfd *ignore_abfd ATTRIBUTE_UNUSED;
+     PTR afile;
+     asymbol *symbol;
+     bfd_print_symbol_type how;
 {
   FILE *file = (FILE *) afile;
   switch (how)
 {
   FILE *file = (FILE *) afile;
   switch (how)
@@ -917,47 +1238,42 @@ DEFUN (srec_print_symbol, (ignore_abfd, afile, symbol, how),
     }
 }
 
     }
 }
 
-#define FOO PROTO
-#define srec_new_section_hook (FOO(boolean, (*), (bfd *, asection *)))bfd_true
-
-#define srec_get_reloc_upper_bound (FOO(unsigned int, (*),(bfd*, asection *)))bfd_false
-#define srec_canonicalize_reloc (FOO(unsigned int, (*),(bfd*,asection *, arelent **, asymbol **))) bfd_0
+#define        srec_close_and_cleanup _bfd_generic_close_and_cleanup
+#define srec_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
+#define srec_new_section_hook _bfd_generic_new_section_hook
 
 
+#define srec_bfd_is_local_label_name bfd_generic_is_local_label_name
+#define srec_get_lineno _bfd_nosymbols_get_lineno
+#define srec_find_nearest_line _bfd_nosymbols_find_nearest_line
+#define srec_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
+#define srec_read_minisymbols _bfd_generic_read_minisymbols
+#define srec_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
 
 
+#define srec_get_reloc_upper_bound \
+  ((long (*) PARAMS ((bfd *, asection *))) bfd_0l)
+#define srec_canonicalize_reloc \
+  ((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))) bfd_0l)
+#define srec_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
 
 
-#define srec_openr_next_archived_file (FOO(bfd *, (*), (bfd*,bfd*))) bfd_nullvoidptr
-#define srec_find_nearest_line (FOO(boolean, (*),(bfd*,asection*,asymbol**,bfd_vma, CONST char**, CONST char**, unsigned int *))) bfd_false
-#define srec_generic_stat_arch_elt  (FOO(int, (*), (bfd *,struct stat *))) bfd_0
+#define srec_get_section_contents_in_window \
+  _bfd_generic_get_section_contents_in_window
 
 
-
-#define srec_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
-#define srec_core_file_failing_signal (int (*)())bfd_0
-#define srec_core_file_matches_executable_p (FOO(boolean, (*),(bfd*, bfd*)))bfd_false
-#define srec_slurp_armap bfd_true
-#define srec_slurp_extended_name_table bfd_true
-#define srec_truncate_arname (void (*)())bfd_nullvoidptr
-#define srec_write_armap  (FOO( boolean, (*),(bfd *, unsigned int, struct orl *, unsigned int, int))) bfd_nullvoidptr
-#define srec_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
-#define        srec_close_and_cleanup  bfd_generic_close_and_cleanup
-#define srec_bfd_debug_info_start bfd_void
-#define srec_bfd_debug_info_end bfd_void
-#define srec_bfd_debug_info_accumulate  (FOO(void, (*), (bfd *,         asection *))) bfd_void
-#define srec_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
+#define srec_bfd_get_relocated_section_contents \
+  bfd_generic_get_relocated_section_contents
 #define srec_bfd_relax_section bfd_generic_relax_section
 #define srec_bfd_relax_section bfd_generic_relax_section
-#define srec_bfd_reloc_type_lookup \
-  ((CONST struct reloc_howto_struct *(*) PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
-#define srec_bfd_make_debug_symbol \
-  ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
+#define srec_bfd_gc_sections bfd_generic_gc_sections
+#define srec_bfd_merge_sections bfd_generic_merge_sections
 #define srec_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
 #define srec_bfd_link_add_symbols _bfd_generic_link_add_symbols
 #define srec_bfd_final_link _bfd_generic_final_link
 #define srec_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
 #define srec_bfd_link_add_symbols _bfd_generic_link_add_symbols
 #define srec_bfd_final_link _bfd_generic_final_link
+#define srec_bfd_link_split_section _bfd_generic_link_split_section
 
 
-bfd_target srec_vec =
+const bfd_target srec_vec =
 {
   "srec",                      /* name */
   bfd_target_srec_flavour,
 {
   "srec",                      /* name */
   bfd_target_srec_flavour,
-  true,                                /* target byte order */
-  true,                                /* target headers byte order */
+  BFD_ENDIAN_UNKNOWN,          /* target byte order */
+  BFD_ENDIAN_UNKNOWN,          /* target headers byte order */
   (HAS_RELOC | EXEC_P |                /* object flags */
    HAS_LINENO | HAS_DEBUG |
    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
   (HAS_RELOC | EXEC_P |                /* object flags */
    HAS_LINENO | HAS_DEBUG |
    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
@@ -966,7 +1282,6 @@ bfd_target srec_vec =
   0,                           /* leading underscore */
   ' ',                         /* ar_pad_char */
   16,                          /* ar_max_namelen */
   0,                           /* leading underscore */
   ' ',                         /* ar_pad_char */
   16,                          /* ar_max_namelen */
-  1,                           /* minimum alignment */
   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
   bfd_getb16, bfd_getb_signed_16, bfd_putb16,  /* data */
   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
   bfd_getb16, bfd_getb_signed_16, bfd_putb16,  /* data */
@@ -977,8 +1292,8 @@ bfd_target srec_vec =
   {
     _bfd_dummy_target,
     srec_object_p,             /* bfd_check_format */
   {
     _bfd_dummy_target,
     srec_object_p,             /* bfd_check_format */
-    (struct bfd_target * (*)()) bfd_nullvoidptr,
-    (struct bfd_target * (*)()) bfd_nullvoidptr,
+    _bfd_dummy_target,
+    _bfd_dummy_target,
   },
   {
     bfd_false,
   },
   {
     bfd_false,
@@ -992,17 +1307,28 @@ bfd_target srec_vec =
     _bfd_write_archive_contents,
     bfd_false,
   },
     _bfd_write_archive_contents,
     bfd_false,
   },
-  JUMP_TABLE (srec)
-};
 
 
+  BFD_JUMP_TABLE_GENERIC (srec),
+  BFD_JUMP_TABLE_COPY (_bfd_generic),
+  BFD_JUMP_TABLE_CORE (_bfd_nocore),
+  BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
+  BFD_JUMP_TABLE_SYMBOLS (srec),
+  BFD_JUMP_TABLE_RELOCS (srec),
+  BFD_JUMP_TABLE_WRITE (srec),
+  BFD_JUMP_TABLE_LINK (srec),
+  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 
 
+  NULL,
 
 
-bfd_target symbolsrec_vec =
+  (PTR) 0
+};
+
+const bfd_target symbolsrec_vec =
 {
   "symbolsrec",                        /* name */
   bfd_target_srec_flavour,
 {
   "symbolsrec",                        /* name */
   bfd_target_srec_flavour,
-  true,                                /* target byte order */
-  true,                                /* target headers byte order */
+  BFD_ENDIAN_UNKNOWN,          /* target byte order */
+  BFD_ENDIAN_UNKNOWN,          /* target headers byte order */
   (HAS_RELOC | EXEC_P |                /* object flags */
    HAS_LINENO | HAS_DEBUG |
    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
   (HAS_RELOC | EXEC_P |                /* object flags */
    HAS_LINENO | HAS_DEBUG |
    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
@@ -1011,7 +1337,6 @@ bfd_target symbolsrec_vec =
   0,                           /* leading underscore */
   ' ',                         /* ar_pad_char */
   16,                          /* ar_max_namelen */
   0,                           /* leading underscore */
   ' ',                         /* ar_pad_char */
   16,                          /* ar_max_namelen */
-  1,                           /* minimum alignment */
   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
   bfd_getb16, bfd_getb_signed_16, bfd_putb16,  /* data */
   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
   bfd_getb16, bfd_getb_signed_16, bfd_putb16,  /* data */
@@ -1022,8 +1347,8 @@ bfd_target symbolsrec_vec =
   {
     _bfd_dummy_target,
     symbolsrec_object_p,       /* bfd_check_format */
   {
     _bfd_dummy_target,
     symbolsrec_object_p,       /* bfd_check_format */
-    (struct bfd_target * (*)()) bfd_nullvoidptr,
-    (struct bfd_target * (*)()) bfd_nullvoidptr,
+    _bfd_dummy_target,
+    _bfd_dummy_target,
   },
   {
     bfd_false,
   },
   {
     bfd_false,
@@ -1037,6 +1362,18 @@ bfd_target symbolsrec_vec =
     _bfd_write_archive_contents,
     bfd_false,
   },
     _bfd_write_archive_contents,
     bfd_false,
   },
-  JUMP_TABLE (srec),
+
+  BFD_JUMP_TABLE_GENERIC (srec),
+  BFD_JUMP_TABLE_COPY (_bfd_generic),
+  BFD_JUMP_TABLE_CORE (_bfd_nocore),
+  BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
+  BFD_JUMP_TABLE_SYMBOLS (srec),
+  BFD_JUMP_TABLE_RELOCS (srec),
+  BFD_JUMP_TABLE_WRITE (srec),
+  BFD_JUMP_TABLE_LINK (srec),
+  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
+
+  NULL,
+
   (PTR) 0
 };
   (PTR) 0
 };
GDB Binutils - Deliverables
This page took 0.041334 seconds and 4 git commands to generate.