Changeset 609 for branches/GNU/src/binutils/bfd/srec.c

Timestamp:

Aug 16, 2003, 6:59:22 PM (22 years ago)

Author:

bird

Message:

binutils v2.14 - offical sources.

File:

• branches/GNU/src/binutils/bfd/srec.c (modified) (70 diffs, 1 prop)

branches/GNU/src/binutils/bfd/srec.c

@@ -1 +1 @@
 /* BFD back-end for s-record objects.
    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-   2000
+   2000, 2001, 2002
    Free Software Foundation, Inc.
    Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
@@ -109 +109 @@
 #include "libbfd.h"
 #include "libiberty.h"
-#include <ctype.h>
+#include "safe-ctype.h"
 
 static void srec_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
@@ -115 +115 @@
  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 bfd_boolean srec_mkobject PARAMS ((bfd *));
+static int srec_get_byte PARAMS ((bfd *, bfd_boolean *));
+static void srec_bad_byte PARAMS ((bfd *, unsigned int, int, bfd_boolean));
+static bfd_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
+static bfd_boolean srec_read_section PARAMS ((bfd *, asection *, bfd_byte *));
+
+static bfd_boolean srec_write_record
+  PARAMS ((bfd *, unsigned int, bfd_vma, const bfd_byte *, const bfd_byte *));
+static bfd_boolean srec_write_header PARAMS ((bfd *));
+static bfd_boolean srec_write_symbols PARAMS ((bfd *));
+static bfd_boolean srec_new_symbol PARAMS ((bfd *, const char *, bfd_vma));
+static bfd_boolean srec_get_section_contents
   PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
-static boolean srec_set_arch_mach
+static bfd_boolean srec_set_arch_mach
   PARAMS ((bfd *, enum bfd_architecture, unsigned long));
-static boolean srec_set_section_contents
+static bfd_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 bfd_boolean internal_srec_write_object_contents PARAMS ((bfd *, int));
+static bfd_boolean srec_write_object_contents PARAMS ((bfd *));
+static bfd_boolean symbolsrec_write_object_contents PARAMS ((bfd *));
+static int srec_sizeof_headers PARAMS ((bfd *, bfd_boolean));
 static long srec_get_symtab_upper_bound PARAMS ((bfd *));
 static long srec_get_symtab PARAMS ((bfd *, asymbol **));
@@ -145 +143 @@
 /* Macros for converting between hex and binary.  */
 
-static CONST char digs[] = "0123456789ABCDEF";
+static const char digs[] = "0123456789ABCDEF";
 
 #define NIBBLE(x) hex_value(x)
@@ -160 +158 @@
 srec_init ()
 {
-  static boolean inited = false;
-
-  if (inited == false)
-    {
-      inited = true;
+  static bfd_boolean inited = FALSE;
+
+  if (! inited)
+    {
+      inited = TRUE;
       hex_init ();
     }
 }
 
-/* The maximum number of bytes on a line is FF.  */
+/* The maximum number of address+data+crc bytes on a line is FF.  */
 #define MAXCHUNK 0xff
 
@@ -175 +173 @@
 #define DEFAULT_CHUNK 16
 
-/* The number of bytes we actually fit onto a line on output.
+/* The number of data 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.  */
@@ -183 +181 @@
    This variable can be modified by objcopy's --srec-forceS3
    parameter.  */
-boolean S3Forced = 0;
+bfd_boolean S3Forced = FALSE;
 
 /* When writing an S-record file, the S-records can not be output as
@@ -222 +220 @@
 tdata_type;
 
-static boolean srec_write_section PARAMS ((bfd *, tdata_type *,
-                                           srec_data_list_type *));
-static boolean srec_write_terminator PARAMS ((bfd *, tdata_type *));
+static bfd_boolean srec_write_section
+  PARAMS ((bfd *, tdata_type *, srec_data_list_type *));
+static bfd_boolean srec_write_terminator
+  PARAMS ((bfd *, tdata_type *));
 
 /* Set up the S-record tdata information.  */
 
-static boolean
+static bfd_boolean
 srec_mkobject (abfd)
      bfd *abfd;
 {
+  bfd_size_type amt;
+  tdata_type *tdata;
+
   srec_init ();
 
-  if (abfd->tdata.srec_data == NULL)
-    {
-      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;
-    }
-
-  return true;
+  amt = sizeof (tdata_type);
+  tdata = (tdata_type *) bfd_alloc (abfd, amt);
+  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;
+
+  return TRUE;
 }
 
@@ -257 +258 @@
 srec_get_byte (abfd, errorptr)
      bfd *abfd;
-     boolean *errorptr;
+     bfd_boolean *errorptr;
 {
   bfd_byte c;
 
-  if (bfd_read (&c, 1, 1, abfd) != 1)
+  if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)
     {
       if (bfd_get_error () != bfd_error_file_truncated)
-        *errorptr = true;
+        *errorptr = TRUE;
       return EOF;
     }
@@ -280 +281 @@
      unsigned int lineno;
      int c;
-     boolean error;
+     bfd_boolean error;
 {
   if (c == EOF)
@@ -291 +292 @@
       char buf[10];
 
-      if (! isprint (c))
+      if (! ISPRINT (c))
         sprintf (buf, "\\%03o", (unsigned int) c);
       else
@@ -300 +301 @@
       (*_bfd_error_handler)
         (_("%s:%d: Unexpected character `%s' in S-record file\n"),
-         bfd_get_filename (abfd), lineno, buf);
+         bfd_archive_filename (abfd), lineno, buf);
       bfd_set_error (bfd_error_bad_value);
     }
@@ -307 +308 @@
 /* Add a new symbol found in an S-record file.  */
 
-static boolean
+static bfd_boolean
 srec_new_symbol (abfd, name, val)
      bfd *abfd;
@@ -314 +315 @@
 {
   struct srec_symbol *n;
-
-  n = (struct srec_symbol *) bfd_alloc (abfd, sizeof (struct srec_symbol));
+  bfd_size_type amt = sizeof (struct srec_symbol);
+
+  n = (struct srec_symbol *) bfd_alloc (abfd, amt);
   if (n == NULL)
-    return false;
+    return FALSE;
 
   n->name = name;
@@ -331 +333 @@
   ++abfd->symcount;
 
-  return true;
+  return TRUE;
 }
 
@@ -337 +339 @@
    section for each contiguous set of bytes.  */
 
-static boolean
+static bfd_boolean
 srec_scan (abfd)
      bfd *abfd;
@@ -343 +345 @@
   int c;
   unsigned int lineno = 1;
-  boolean error = false;
+  bfd_boolean error = FALSE;
   bfd_byte *buf = NULL;
   size_t bufsize = 0;
@@ -355 +357 @@
     {
       /* We only build sections from contiguous S-records, so if this
-         is not an S-record, then stop building a section.  */
+         is not an S-record, then stop building a section.  */
       if (c != 'S' && c != '\r' && c != '\n')
         sec = NULL;
@@ -390 +392 @@
           do
             {
-              unsigned int alc;
+              bfd_size_type alc;
               char *p, *symname;
               bfd_vma symval;
@@ -417 +419 @@
               *p++ = c;
               while ((c = srec_get_byte (abfd, &error)) != EOF
-                     && ! isspace (c))
+                     && ! ISSPACE (c))
                 {
-                  if ((unsigned int) (p - symbuf) >= alc)
+                  if ((bfd_size_type) (p - symbuf) >= alc)
                     {
                       char *n;
@@ -441 +443 @@
 
               *p++ = '\0';
-              symname = bfd_alloc (abfd, p - symbuf);
+              symname = bfd_alloc (abfd, (bfd_size_type) (p - symbuf));
               if (symname == NULL)
                 goto error_return;
@@ -504 +506 @@
             pos = bfd_tell (abfd) - 1;
 
-            if (bfd_read (hdr, 1, 3, abfd) != 3)
+            if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)
               goto error_return;
 
@@ -522 +524 @@
                 if (buf != NULL)
                   free (buf);
-                buf = (bfd_byte *) bfd_malloc (bytes * 2);
+                buf = (bfd_byte *) bfd_malloc ((bfd_size_type) bytes * 2);
                 if (buf == NULL)
                   goto error_return;
@@ -528 +530 @@
               }
 
-            if (bfd_read (buf, 1, bytes * 2, abfd) != bytes * 2)
+            if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2)
               goto error_return;
 
@@ -541 +543 @@
               case '5':
                 /* Prologue--ignore the file name, but stop building a
-                   section at this point.  */
+                   section at this point.  */
                 sec = NULL;
                 break;
@@ -566 +568 @@
                   {
                     /* This data goes at the end of the section we are
-                       currently building.  */
+                       currently building.  */
                     sec->_raw_size += bytes;
                   }
@@ -573 +575 @@
                     char secbuf[20];
                     char *secname;
+                    bfd_size_type amt;
 
                     sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
-                    secname = (char *) bfd_alloc (abfd, strlen (secbuf) + 1);
+                    amt = strlen (secbuf) + 1;
+                    secname = (char *) bfd_alloc (abfd, amt);
                     strcpy (secname, secbuf);
                     sec = bfd_make_section (abfd, secname);
@@ -609 +613 @@
                   free (buf);
 
-                return true;
+                return TRUE;
               }
           }
@@ -622 +626 @@
     free (buf);
 
-  return true;
+  return TRUE;
 
  error_return:
@@ -629 +633 @@
   if (buf != NULL)
     free (buf);
-  return false;
+  return FALSE;
 }
 
@@ -638 +642 @@
      bfd *abfd;
 {
+  PTR tdata_save;
   bfd_byte b[4];
 
@@ -643 +648 @@
 
   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
-      || bfd_read (b, 1, 4, abfd) != 4)
+      || bfd_bread (b, (bfd_size_type) 4, abfd) != 4)
     return NULL;
 
@@ -652 +657 @@
     }
 
-  if (! srec_mkobject (abfd)
-      || ! srec_scan (abfd))
-    return NULL;
+  tdata_save = abfd->tdata.any;
+  if (! srec_mkobject (abfd) || ! srec_scan (abfd))
+    {
+      if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
+        bfd_release (abfd, abfd->tdata.any);
+      abfd->tdata.any = tdata_save;
+      return NULL;
+    }
 
   if (abfd->symcount > 0)
@@ -668 +678 @@
      bfd *abfd;
 {
+  PTR tdata_save;
   char b[2];
 
@@ -673 +684 @@
 
   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
-      || bfd_read (b, 1, 2, abfd) != 2)
+      || bfd_bread (b, (bfd_size_type) 2, abfd) != 2)
     return NULL;
 
@@ -682 +693 @@
     }
 
-  if (! srec_mkobject (abfd)
-      || ! srec_scan (abfd))
-    return NULL;
+  tdata_save = abfd->tdata.any;
+  if (! srec_mkobject (abfd) || ! srec_scan (abfd))
+    {
+      if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
+        bfd_release (abfd, abfd->tdata.any);
+      abfd->tdata.any = tdata_save;
+      return NULL;
+    }
 
   if (abfd->symcount > 0)
@@ -694 +710 @@
 /* Read in the contents of a section in an S-record file.  */
 
-static boolean
+static bfd_boolean
 srec_read_section (abfd, section, contents)
      bfd *abfd;
@@ -702 +718 @@
   int c;
   bfd_size_type sofar = 0;
-  boolean error = false;
+  bfd_boolean error = FALSE;
   bfd_byte *buf = NULL;
   size_t bufsize = 0;
@@ -720 +736 @@
 
       /* This is called after srec_scan has already been called, so we
-         ought to know the exact format.  */
+         ought to know the exact format.  */
       BFD_ASSERT (c == 'S');
 
-      if (bfd_read (hdr, 1, 3, abfd) != 3)
+      if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)
         goto error_return;
 
@@ -734 +750 @@
           if (buf != NULL)
             free (buf);
-          buf = (bfd_byte *) bfd_malloc (bytes * 2);
+          buf = (bfd_byte *) bfd_malloc ((bfd_size_type) bytes * 2);
           if (buf == NULL)
             goto error_return;
@@ -740 +756 @@
         }
 
-      if (bfd_read (buf, 1, bytes * 2, abfd) != bytes * 2)
+      if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2)
         goto error_return;
 
@@ -751 +767 @@
           if (buf != NULL)
             free (buf);
-          return true;
+          return TRUE;
 
         case '3':
@@ -776 +792 @@
               if (buf != NULL)
                 free (buf);
-              return true;
+              return TRUE;
             }
 
@@ -801 +817 @@
     free (buf);
 
-  return true;
+  return TRUE;
 
  error_return:
   if (buf != NULL)
     free (buf);
-  return false;
+  return FALSE;
 }
 
 /* Get the contents of a section in an S-record file.  */
 
-static boolean
+static bfd_boolean
 srec_get_section_contents (abfd, section, location, offset, count)
      bfd *abfd;
@@ -822 +838 @@
     {
       section->used_by_bfd = bfd_alloc (abfd, section->_raw_size);
-      if (section->used_by_bfd == NULL
-          && section->_raw_size != 0)
-        return false;
+      if (section->used_by_bfd == NULL && section->_raw_size != 0)
+        return FALSE;
 
       if (! srec_read_section (abfd, section, section->used_by_bfd))
-        return false;
+        return FALSE;
     }
 
@@ -833 +848 @@
           (size_t) count);
 
-  return true;
+  return TRUE;
 }
 
 /* Set the architecture.  We accept an unknown architecture here.  */
 
-static boolean
+static bfd_boolean
 srec_set_arch_mach (abfd, arch, mach)
      bfd *abfd;
@@ -847 +862 @@
     {
       abfd->arch_info = &bfd_default_arch_struct;
-      return true;
+      return TRUE;
     }
   return bfd_default_set_arch_mach (abfd, arch, mach);
@@ -854 +869 @@
 /* We have to save up all the Srecords for a splurge before output.  */
 
-static boolean
+static bfd_boolean
 srec_set_section_contents (abfd, section, location, offset, bytes_to_do)
      bfd *abfd;
@@ -866 +881 @@
 
   entry = ((srec_data_list_type *)
-           bfd_alloc (abfd, sizeof (srec_data_list_type)));
+           bfd_alloc (abfd, (bfd_size_type) sizeof (srec_data_list_type)));
   if (entry == NULL)
-    return false;
+    return FALSE;
 
   if (bytes_to_do
@@ -874 +889 @@
       && (section->flags & SEC_LOAD))
     {
-      bfd_byte *data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do);
+      bfd_byte *data;
+
+      data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do);
       if (data == NULL)
-        return false;
+        return FALSE;
       memcpy ((PTR) data, location, (size_t) bytes_to_do);
 
-      /* Ff S3Forced is true then always select S3 records,
+      /* Ff S3Forced is TRUE then always select S3 records,
          regardless of the siez of the addresses.  */
       if (S3Forced)
@@ -896 +913 @@
 
       /* Sort the records by address.  Optimize for the common case of
-         adding a record to the end of the list.  */
+         adding a record to the end of the list.  */
       if (tdata->tail != NULL
           && entry->where >= tdata->tail->where)
@@ -918 +935 @@
         }
     }
-  return true;
+  return TRUE;
 }
 
@@ -925 +942 @@
    here.  */
 
-static boolean
+static bfd_boolean
 srec_write_record (abfd, type, address, data, end)
      bfd *abfd;
-     int type;
+     unsigned int type;
      bfd_vma address;
      const bfd_byte *data;
      const bfd_byte *end;
 {
-  char buffer[MAXCHUNK];
+  char buffer[2 * MAXCHUNK + 6];
   unsigned int check_sum = 0;
-  CONST bfd_byte *src = data;
+  const bfd_byte *src = data;
   char *dst = buffer;
   char *length;
@@ -982 +999 @@
   *dst++ = '\n';
   wrlen = dst - buffer;
-  if (bfd_write ((PTR) buffer, 1, wrlen, abfd) != wrlen)
-    return false;
-  return true;
-}
-
-static boolean
+  if (bfd_bwrite ((PTR) buffer, wrlen, abfd) != wrlen)
+    return FALSE;
+  return TRUE;
+}
+
+static bfd_boolean
 srec_write_header (abfd)
      bfd *abfd;
 {
-  bfd_byte buffer[MAXCHUNK];
-  bfd_byte *dst = buffer;
-  unsigned int i;
+  unsigned int len = strlen (abfd->filename);
 
   /* I'll put an arbitary 40 char limit on header size.  */
-  for (i = 0; i < 40 && abfd->filename[i]; i++)
-    *dst++ = abfd->filename[i];
-
-  return srec_write_record (abfd, 0, 0, buffer, dst);
-}
-
-static boolean
+  if (len > 40)
+    len = 40;
+
+  return srec_write_record (abfd, 0, (bfd_vma) 0,
+                            abfd->filename, abfd->filename + len);
+}
+
+static bfd_boolean
 srec_write_section (abfd, tdata, list)
      bfd *abfd;
@@ -1010 +1026 @@
   unsigned int octets_written = 0;
   bfd_byte *location = list->data;
+
+  /* Validate number of data bytes to write.  The srec length byte
+     counts the address, data and crc bytes.  S1 (tdata->type == 1)
+     records have two address bytes, S2 (tdata->type == 2) records
+     have three, and S3 (tdata->type == 3) records have four.
+     The total length can't exceed 255, and a zero data length will
+     spin for a long time.  */
+  if (Chunk == 0)
+    Chunk = 1;
+  else if (Chunk > MAXCHUNK - tdata->type - 2)
+    Chunk = MAXCHUNK - tdata->type - 2;
 
   while (octets_written < list->size)
@@ -1026 +1053 @@
                                location,
                                location + octets_this_chunk))
-        return false;
+        return FALSE;
 
       octets_written += octets_this_chunk;
@@ -1032 +1059 @@
     }
 
-  return true;
-}
-
-static boolean
+  return TRUE;
+}
+
+static bfd_boolean
 srec_write_terminator (abfd, tdata)
      bfd *abfd;
      tdata_type *tdata;
 {
-  bfd_byte buffer[2];
-
   return srec_write_record (abfd, 10 - tdata->type,
-                            abfd->start_address, buffer, buffer);
-}
-
-static boolean
+                            abfd->start_address, NULL, NULL);
+}
+
+static bfd_boolean
 srec_write_symbols (abfd)
      bfd *abfd;
 {
-  char buffer[MAXCHUNK];
   /* Dump out the symbols of a bfd.  */
   int i;
@@ -1057 +1081 @@
   if (count)
     {
-      size_t len;
+      bfd_size_type len;
       asymbol **table = bfd_get_outsymbols (abfd);
-      sprintf (buffer, "$$ %s\r\n", abfd->filename);
-
-      len = strlen (buffer);
-      if (bfd_write (buffer, len, 1, abfd) != len)
-        return false;
+      len = strlen (abfd->filename);
+      if (bfd_bwrite ("$$ ", (bfd_size_type) 3, abfd) != 3
+          || bfd_bwrite (abfd->filename, len, abfd) != len
+          || bfd_bwrite ("\r\n", (bfd_size_type) 2, abfd) != 2)
+        return FALSE;
 
       for (i = 0; i < count; i++)
@@ -1072 +1096 @@
             {
               /* Just dump out non debug symbols.  */
-              bfd_size_type l;
-              char buf2[40], *p;
-
-              sprintf_vma (buf2,
-                           s->value + s->section->output_section->lma
-                           + s->section->output_offset);
-              p = buf2;
+              char buf[43], *p;
+
+              len = strlen (s->name);
+              if (bfd_bwrite ("  ", (bfd_size_type) 2, abfd) != 2
+                  || bfd_bwrite (s->name, len, abfd) != len)
+                return FALSE;
+
+              sprintf_vma (buf + 2, (s->value
+                                     + s->section->output_section->lma
+                                     + s->section->output_offset));
+              p = buf + 2;
               while (p[0] == '0' && p[1] != 0)
                 p++;
-              sprintf (buffer, "  %s $%s\r\n", s->name, p);
-              l = strlen (buffer);
-              if (bfd_write (buffer, l, 1, abfd) != l)
-                return false;
+              len = strlen (p);
+              p[len] = '\r';
+              p[len + 1] = '\n';
+              *--p = '$';
+              *--p = ' ';
+              len += 4;
+              if (bfd_bwrite (p, len, abfd) != len)
+                return FALSE;
             }
         }
-      sprintf (buffer, "$$ \r\n");
-      len = strlen (buffer);
-      if (bfd_write (buffer, len, 1, abfd) != len)
-        return false;
-    }
-
-  return true;
-}
-
-static boolean
+      if (bfd_bwrite ("$$ \r\n", (bfd_size_type) 5, abfd) != 5)
+        return FALSE;
+    }
+
+  return TRUE;
+}
+
+static bfd_boolean
 internal_srec_write_object_contents (abfd, symbols)
      bfd *abfd;
@@ -1107 +1137 @@
     {
       if (! srec_write_symbols (abfd))
-        return false;
+        return FALSE;
     }
 
   if (! srec_write_header (abfd))
-    return false;
+    return FALSE;
 
   /* Now wander though all the sections provided and output them.  */
@@ -1119 +1149 @@
     {
       if (! srec_write_section (abfd, tdata, list))
-        return false;
+        return FALSE;
       list = list->next;
     }
@@ -1125 +1155 @@
 }
 
-static boolean
+static bfd_boolean
 srec_write_object_contents (abfd)
      bfd *abfd;
@@ -1132 +1162 @@
 }
 
-static boolean
+static bfd_boolean
 symbolsrec_write_object_contents (abfd)
      bfd *abfd;
@@ -1142 +1172 @@
 srec_sizeof_headers (abfd, exec)
      bfd *abfd ATTRIBUTE_UNUSED;
-     boolean exec ATTRIBUTE_UNUSED;
+     bfd_boolean exec ATTRIBUTE_UNUSED;
 {
   return 0;
-}
-
-static asymbol *
-srec_make_empty_symbol (abfd)
-     bfd *abfd;
-{
-  asymbol *new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
-  if (new)
-    new->the_bfd = abfd;
-  return new;
 }
 
@@ -1173 +1193 @@
      asymbol **alocation;
 {
-  unsigned int symcount = bfd_get_symcount (abfd);
+  bfd_size_type symcount = bfd_get_symcount (abfd);
   asymbol *csymbols;
   unsigned int i;
@@ -1185 +1205 @@
       csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));
       if (csymbols == NULL && symcount != 0)
-        return false;
+        return 0;
       abfd->tdata.srec_data->csymbols = csymbols;
 
@@ -1218 +1238 @@
 
 static void
-srec_print_symbol (ignore_abfd, afile, symbol, how)
-     bfd *ignore_abfd ATTRIBUTE_UNUSED;
+srec_print_symbol (abfd, afile, symbol, how)
+     bfd *abfd;
      PTR afile;
      asymbol *symbol;
@@ -1231 +1251 @@
       break;
     default:
-      bfd_print_symbol_vandf ((PTR) file, symbol);
+      bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
       fprintf (file, " %-5s %s",
                symbol->section->name,
@@ -1246 +1266 @@
 #define srec_get_lineno _bfd_nosymbols_get_lineno
 #define srec_find_nearest_line _bfd_nosymbols_find_nearest_line
+#define srec_make_empty_symbol _bfd_generic_make_empty_symbol
 #define srec_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
 #define srec_read_minisymbols _bfd_generic_read_minisymbols
@@ -1263 +1284 @@
 #define srec_bfd_relax_section bfd_generic_relax_section
 #define srec_bfd_gc_sections bfd_generic_gc_sections
+#define srec_bfd_merge_sections bfd_generic_merge_sections
+#define srec_bfd_discard_group bfd_generic_discard_group
 #define srec_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
+#define srec_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
 #define srec_bfd_link_add_symbols _bfd_generic_link_add_symbols
+#define srec_bfd_link_just_syms _bfd_generic_link_just_syms
 #define srec_bfd_final_link _bfd_generic_final_link
 #define srec_bfd_link_split_section _bfd_generic_link_split_section