Fix build error in gdb/rocm-tdep.c

[deliverable/binutils-gdb.git] / bfd / srec.c

diff --git a/bfd/srec.c b/bfd/srec.c
index 129b2ba4bb53cbbcf987e81a4943414f1143c485..a370b775bc90c0d89906a991c681a3adf599474e 100644 (file)
--- a/bfd/srec.c
+++ b/bfd/srec.c
@@ -1,30 +1,29 @@
 /* BFD back-end for s-record objects.
 /* BFD back-end for s-record objects.

-   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-   2000, 2001, 2002
-   Free Software Foundation, Inc.
+   Copyright (C) 1990-2020 Free Software Foundation, Inc.

    Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
 
    Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
 

-This file is part of BFD, the Binary File Descriptor library.
+   This file is part of BFD, the Binary File Descriptor library.

 
 

-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.

 
 

-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   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., 51 Franklin Street - Fifth Floor, Boston,
+   MA 02110-1301, USA.  */

 
 

-/*
-SUBSECTION
+
+/* SUBSECTION

        S-Record handling
 
        S-Record handling
 

-DESCRIPTION
+   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.


@@ -44,10 +43,10 @@ DESCRIPTION
 
        An s record looks like:
 
 
        An s record looks like:
 

-EXAMPLE
+   EXAMPLE

        S<type><length><address><data><checksum>
 
        S<type><length><address><data><checksum>
 

-DESCRIPTION
+   DESCRIPTION

        Where
        o length
        is the number of bytes following upto the checksum. Note that
        Where
        o length
        is the number of bytes following upto the checksum. Note that


@@ -72,10 +71,10 @@ 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
+   SUBSECTION

        Symbol S-Record handling
 
        Symbol S-Record handling
 

-DESCRIPTION
+   DESCRIPTION

        Some ICE equipment understands an addition to the standard
        S-Record format; symbols and their addresses can be sent
        before the data.
        Some ICE equipment understands an addition to the standard
        S-Record format; symbols and their addresses can be sent
        before the data.


@@ -87,7 +86,7 @@ DESCRIPTION
 
        so a short symbol table could look like:
 
 
        so a short symbol table could look like:
 

-EXAMPLE
+   EXAMPLE

        $$ flash.x
        $$ flash.c
          _port6 $0
        $$ flash.x
        $$ flash.c
          _port6 $0


@@ -95,77 +94,31 @@ EXAMPLE
          _start $14
          _etext $8036
          _edata $8036
          _start $14
          _etext $8036
          _edata $8036

-         _end $8036
+         _end $8036

        $$
 
        $$
 

-DESCRIPTION
+   DESCRIPTION

        We allow symbols to be anywhere in the data stream - the module names
        We allow symbols to be anywhere in the data stream - the module names

-       are always ignored.
-
-*/
+       are always ignored.  */

 
 

-#include "bfd.h"

 #include "sysdep.h"
 #include "sysdep.h"

+#include "bfd.h"

 #include "libbfd.h"
 #include "libiberty.h"
 #include "safe-ctype.h"
 
 #include "libbfd.h"
 #include "libiberty.h"
 #include "safe-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 *, unsigned 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 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";
 
 
 /* Macros for converting between hex and binary.  */
 
 static const char digs[] = "0123456789ABCDEF";
 

-#define NIBBLE(x) hex_value(x)
-#define HEX(buffer) ((NIBBLE((buffer)[0])<<4) + NIBBLE((buffer)[1]))
+#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 TOHEX(d, x, ch) \
        d[1] = digs[(x) & 0xf]; \
        d[0] = digs[((x)>>4)&0xf]; \
        ch += ((x) & 0xff);

-#define        ISHEX(x)  hex_p(x)
-
-/* Initialize by filling in the hex conversion array.  */
-
-static void
-srec_init ()
-{
-  static boolean inited = false;
-
-  if (! inited)
-    {
-      inited = true;
-      hex_init ();
-    }
-}
+#define        ISHEX(x)    hex_p(x)

 
 /* The maximum number of address+data+crc bytes on a line is FF.  */
 #define MAXCHUNK 0xff
 
 /* The maximum number of address+data+crc bytes on a line is FF.  */
 #define MAXCHUNK 0xff


@@ -176,12 +129,12 @@ srec_init ()
 /* 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.  */
 /* 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.  */

-unsigned int Chunk = DEFAULT_CHUNK;
+unsigned int _bfd_srec_len = DEFAULT_CHUNK;

 
 /* The type of srec output (free or forced to S3).
    This variable can be modified by objcopy's --srec-forceS3
    parameter.  */
 
 /* The type of srec output (free or forced to S3).
    This variable can be modified by objcopy's --srec-forceS3
    parameter.  */

-boolean S3Forced = 0;
+bfd_boolean _bfd_srec_forceS3 = FALSE;

 
 /* 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.  */
 
 /* 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.  */


@@ -220,26 +173,33 @@ typedef struct srec_data_struct
   }
 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 *));
+/* Initialize by filling in the hex conversion array.  */
+
+static void
+srec_init (void)
+{
+  static bfd_boolean inited = FALSE;
+
+  if (! inited)
+    {
+      inited = TRUE;
+      hex_init ();
+    }
+}

 
 /* Set up the S-record tdata information.  */
 
 
 /* Set up the S-record tdata information.  */
 

-static boolean
-srec_mkobject (abfd)
-     bfd *abfd;
+static bfd_boolean
+srec_mkobject (bfd *abfd)

 {
 {

-  bfd_size_type amt;

   tdata_type *tdata;
 
   srec_init ();
 
   tdata_type *tdata;
 
   srec_init ();
 

-  amt = sizeof (tdata_type);
-  tdata = (tdata_type *) bfd_alloc (abfd, amt);
+  tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));

   if (tdata == NULL)
   if (tdata == NULL)

-    return false;
-    
+    return FALSE;
+

   abfd->tdata.srec_data = tdata;
   tdata->type = 1;
   tdata->head = NULL;
   abfd->tdata.srec_data = tdata;
   tdata->type = 1;
   tdata->head = NULL;


@@ -248,23 +208,21 @@ srec_mkobject (abfd)
   tdata->symtail = NULL;
   tdata->csymbols = NULL;
 
   tdata->symtail = NULL;
   tdata->csymbols = NULL;
 

-  return true;
+  return TRUE;

 }
 
 /* Read a byte from an S record file.  Set *ERRORPTR if an error
    occurred.  Return EOF on error or end of file.  */
 
 static int
 }
 
 /* Read a byte from an S record file.  Set *ERRORPTR if an error
    occurred.  Return EOF on error or end of file.  */
 
 static int

-srec_get_byte (abfd, errorptr)
-     bfd *abfd;
-     boolean *errorptr;
+srec_get_byte (bfd *abfd, bfd_boolean *errorptr)

 {
   bfd_byte c;
 
   if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)
     {
       if (bfd_get_error () != bfd_error_file_truncated)
 {
   bfd_byte c;
 
   if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)
     {
       if (bfd_get_error () != bfd_error_file_truncated)

-       *errorptr = true;
+       *errorptr = TRUE;

       return EOF;
     }
 
       return EOF;
     }
 


@@ -276,11 +234,10 @@ srec_get_byte (abfd, errorptr)
    error messages.  */
 
 static void
    error messages.  */
 
 static void

-srec_bad_byte (abfd, lineno, c, error)
-     bfd *abfd;
-     unsigned int lineno;
-     int c;
-     boolean error;
+srec_bad_byte (bfd *abfd,
+              unsigned int lineno,
+              int c,
+              bfd_boolean error)

 {
   if (c == EOF)
     {
 {
   if (c == EOF)
     {


@@ -289,36 +246,33 @@ srec_bad_byte (abfd, lineno, c, error)
     }
   else
     {
     }
   else
     {

-      char buf[10];
+      char buf[40];

 
       if (! ISPRINT (c))
 
       if (! ISPRINT (c))

-       sprintf (buf, "\\%03o", (unsigned int) c);
+       sprintf (buf, "\\%03o", (unsigned int) c & 0xff);

       else
        {
          buf[0] = c;
          buf[1] = '\0';
        }
       else
        {
          buf[0] = c;
          buf[1] = '\0';
        }

-      (*_bfd_error_handler)
-       (_("%s:%d: Unexpected character `%s' in S-record file\n"),
-        bfd_archive_filename (abfd), lineno, buf);
+      _bfd_error_handler
+       /* xgettext:c-format */
+       (_("%pB:%d: unexpected character `%s' in S-record file"),
+        abfd, lineno, buf);

       bfd_set_error (bfd_error_bad_value);
     }
 }
 
 /* Add a new symbol found in an S-record file.  */
 
       bfd_set_error (bfd_error_bad_value);
     }
 }
 
 /* Add a new symbol found in an S-record file.  */
 

-static boolean
-srec_new_symbol (abfd, name, val)
-     bfd *abfd;
-     const char *name;
-     bfd_vma val;
+static bfd_boolean
+srec_new_symbol (bfd *abfd, const char *name, bfd_vma val)

 {
   struct srec_symbol *n;
 {
   struct srec_symbol *n;

-  bfd_size_type amt = sizeof (struct srec_symbol);

 
 

-  n = (struct srec_symbol *) bfd_alloc (abfd, amt);
+  n = (struct srec_symbol *) bfd_alloc (abfd, sizeof (* n));

   if (n == NULL)
   if (n == NULL)

-    return false;
+    return FALSE;

 
   n->name = name;
   n->val = val;
 
   n->name = name;
   n->val = val;


@@ -332,19 +286,18 @@ srec_new_symbol (abfd, name, val)
 
   ++abfd->symcount;
 
 
   ++abfd->symcount;
 

-  return true;
+  return TRUE;

 }
 
 /* Read the S record file and turn it into sections.  We create a new
    section for each contiguous set of bytes.  */
 
 }
 
 /* Read the S record file and turn it into sections.  We create a new
    section for each contiguous set of bytes.  */
 

-static boolean
-srec_scan (abfd)
-     bfd *abfd;
+static bfd_boolean
+srec_scan (bfd *abfd)

 {
   int c;
   unsigned int lineno = 1;
 {
   int c;
   unsigned int lineno = 1;

-  boolean error = false;
+  bfd_boolean error = FALSE;

   bfd_byte *buf = NULL;
   size_t bufsize = 0;
   asection *sec = NULL;
   bfd_byte *buf = NULL;
   size_t bufsize = 0;
   asection *sec = NULL;


@@ -356,7 +309,7 @@ srec_scan (abfd)
   while ((c = srec_get_byte (abfd, &error)) != EOF)
     {
       /* We only build sections from contiguous S-records, so if this
   while ((c = srec_get_byte (abfd, &error)) != EOF)
     {
       /* 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;
 
       if (c != 'S' && c != '\r' && c != '\n')
        sec = NULL;
 


@@ -385,7 +338,6 @@ srec_scan (abfd)
            }
 
          ++lineno;
            }
 
          ++lineno;

-

          break;
 
        case ' ':
          break;
 
        case ' ':


@@ -442,7 +394,7 @@ srec_scan (abfd)
                }
 
              *p++ = '\0';
                }
 
              *p++ = '\0';

-             symname = bfd_alloc (abfd, (bfd_size_type) (p - symbuf));
+             symname = (char *) bfd_alloc (abfd, (bfd_size_type) (p - symbuf));

              if (symname == NULL)
                goto error_return;
              strcpy (symname, symbuf);
              if (symname == NULL)
                goto error_return;
              strcpy (symname, symbuf);


@@ -475,6 +427,11 @@ srec_scan (abfd)
                  symval <<= 4;
                  symval += NIBBLE (c);
                  c = srec_get_byte (abfd, &error);
                  symval <<= 4;
                  symval += NIBBLE (c);
                  c = srec_get_byte (abfd, &error);

+                 if (c == EOF)
+                   {
+                     srec_bad_byte (abfd, lineno, c, error);
+                     goto error_return;
+                   }

                }
 
              if (! srec_new_symbol (abfd, symname, symval))
                }
 
              if (! srec_new_symbol (abfd, symname, symval))


@@ -496,10 +453,11 @@ srec_scan (abfd)
        case 'S':
          {
            file_ptr pos;
        case 'S':
          {
            file_ptr pos;

-           char hdr[3];
-           unsigned int bytes;
+           unsigned char hdr[3];
+           unsigned int bytes, min_bytes;

            bfd_vma address;
            bfd_byte *data;
            bfd_vma address;
            bfd_byte *data;

+           unsigned char check_sum;

 
            /* Starting an S-record.  */
 
 
            /* Starting an S-record.  */
 


@@ -518,7 +476,21 @@ srec_scan (abfd)
                goto error_return;
              }
 
                goto error_return;
              }
 

-           bytes = HEX (hdr + 1);
+           check_sum = bytes = HEX (hdr + 1);
+           min_bytes = 3;
+           if (hdr[0] == '2' || hdr[0] == '8')
+             min_bytes = 4;
+           else if (hdr[0] == '3' || hdr[0] == '7')
+             min_bytes = 5;
+           if (bytes < min_bytes)
+             {
+               /* xgettext:c-format */
+               _bfd_error_handler (_("%pB:%d: byte count %d too small"),
+                                   abfd, lineno, bytes);
+               bfd_set_error (bfd_error_bad_value);
+               goto error_return;
+             }
+

            if (bytes * 2 > bufsize)
              {
                if (buf != NULL)
            if (bytes * 2 > bufsize)
              {
                if (buf != NULL)


@@ -542,77 +514,114 @@ srec_scan (abfd)
              case '0':
              case '5':
                /* Prologue--ignore the file name, but stop building a
              case '0':
              case '5':
                /* Prologue--ignore the file name, but stop building a

-                   section at this point.  */
+                  section at this point.  */

                sec = NULL;
                break;
 
              case '3':
                sec = NULL;
                break;
 
              case '3':

+               check_sum += HEX (data);

                address = HEX (data);
                data += 2;
                --bytes;
                /* Fall through.  */
              case '2':
                address = HEX (data);
                data += 2;
                --bytes;
                /* Fall through.  */
              case '2':

+               check_sum += HEX (data);

                address = (address << 8) | HEX (data);
                data += 2;
                --bytes;
                /* Fall through.  */
              case '1':
                address = (address << 8) | HEX (data);
                data += 2;
                --bytes;
                /* Fall through.  */
              case '1':

+               check_sum += HEX (data);

                address = (address << 8) | HEX (data);
                data += 2;
                address = (address << 8) | HEX (data);
                data += 2;

+               check_sum += HEX (data);

                address = (address << 8) | HEX (data);
                data += 2;
                bytes -= 2;
 
                if (sec != NULL
                address = (address << 8) | HEX (data);
                data += 2;
                bytes -= 2;
 
                if (sec != NULL

-                   && sec->vma + sec->_raw_size == address)
+                   && sec->vma + sec->size == address)

                  {
                    /* This data goes at the end of the section we are
                  {
                    /* This data goes at the end of the section we are

-                       currently building.  */
-                   sec->_raw_size += bytes;
+                      currently building.  */
+                   sec->size += bytes;

                  }
                else
                  {
                    char secbuf[20];
                    char *secname;
                    bfd_size_type amt;
                  }
                else
                  {
                    char secbuf[20];
                    char *secname;
                    bfd_size_type amt;

+                   flagword flags;

 
                    sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
                    amt = strlen (secbuf) + 1;
                    secname = (char *) bfd_alloc (abfd, amt);
                    strcpy (secname, secbuf);
 
                    sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
                    amt = strlen (secbuf) + 1;
                    secname = (char *) bfd_alloc (abfd, amt);
                    strcpy (secname, secbuf);

-                   sec = bfd_make_section (abfd, secname);
+                   flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
+                   sec = bfd_make_section_with_flags (abfd, secname, flags);

                    if (sec == NULL)
                      goto error_return;
                    if (sec == NULL)
                      goto error_return;

-                   sec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;

                    sec->vma = address;
                    sec->lma = address;
                    sec->vma = address;
                    sec->lma = address;

-                   sec->_raw_size = bytes;
+                   sec->size = bytes;

                    sec->filepos = pos;
                  }
 
                    sec->filepos = pos;
                  }
 

+               while (bytes > 0)
+                 {
+                   check_sum += HEX (data);
+                   data += 2;
+                   bytes--;
+                 }
+               check_sum = 255 - (check_sum & 0xff);
+               if (check_sum != HEX (data))
+                 {
+                   _bfd_error_handler
+                     /* xgettext:c-format */
+                     (_("%pB:%d: bad checksum in S-record file"),
+                      abfd, lineno);
+                   bfd_set_error (bfd_error_bad_value);
+                   goto error_return;
+                 }
+

                break;
 
              case '7':
                break;
 
              case '7':

+               check_sum += HEX (data);

                address = HEX (data);
                data += 2;
                /* Fall through.  */
              case '8':
                address = HEX (data);
                data += 2;
                /* Fall through.  */
              case '8':

+               check_sum += HEX (data);

                address = (address << 8) | HEX (data);
                data += 2;
                /* Fall through.  */
              case '9':
                address = (address << 8) | HEX (data);
                data += 2;
                /* Fall through.  */
              case '9':

+               check_sum += HEX (data);

                address = (address << 8) | HEX (data);
                data += 2;
                address = (address << 8) | HEX (data);
                data += 2;

+               check_sum += HEX (data);

                address = (address << 8) | HEX (data);
                data += 2;
 
                /* This is a termination record.  */
                abfd->start_address = address;
 
                address = (address << 8) | HEX (data);
                data += 2;
 
                /* This is a termination record.  */
                abfd->start_address = address;
 

+               check_sum = 255 - (check_sum & 0xff);
+               if (check_sum != HEX (data))
+                 {
+                   _bfd_error_handler
+                     /* xgettext:c-format */
+                     (_("%pB:%d: bad checksum in S-record file"),
+                      abfd, lineno);
+                   bfd_set_error (bfd_error_bad_value);
+                   goto error_return;
+                 }
+

                if (buf != NULL)
                  free (buf);
 
                if (buf != NULL)
                  free (buf);
 

-               return true;
+               return TRUE;

              }
          }
          break;
              }
          }
          break;


@@ -625,23 +634,22 @@ srec_scan (abfd)
   if (buf != NULL)
     free (buf);
 
   if (buf != NULL)
     free (buf);
 

-  return true;
+  return TRUE;

 
  error_return:
   if (symbuf != NULL)
     free (symbuf);
   if (buf != NULL)
     free (buf);
 
  error_return:
   if (symbuf != NULL)
     free (symbuf);
   if (buf != NULL)
     free (buf);

-  return false;
+  return FALSE;

 }
 
 /* Check whether an existing file is an S-record file.  */
 
 static const bfd_target *
 }
 
 /* Check whether an existing file is an S-record file.  */
 
 static const bfd_target *

-srec_object_p (abfd)
-     bfd *abfd;
+srec_object_p (bfd *abfd)

 {
 {

-  PTR tdata_save;
+  void * tdata_save;

   bfd_byte b[4];
 
   srec_init ();
   bfd_byte b[4];
 
   srec_init ();


@@ -674,10 +682,9 @@ srec_object_p (abfd)
 /* Check whether an existing file is an S-record file with symbols.  */
 
 static const bfd_target *
 /* Check whether an existing file is an S-record file with symbols.  */
 
 static const bfd_target *

-symbolsrec_object_p (abfd)
-     bfd *abfd;
+symbolsrec_object_p (bfd *abfd)

 {
 {

-  PTR tdata_save;
+  void * tdata_save;

   char b[2];
 
   srec_init ();
   char b[2];
 
   srec_init ();


@@ -709,15 +716,12 @@ symbolsrec_object_p (abfd)
 
 /* Read in the contents of a section in an S-record file.  */
 
 
 /* Read in the contents of a section in an S-record file.  */
 

-static boolean
-srec_read_section (abfd, section, contents)
-     bfd *abfd;
-     asection *section;
-     bfd_byte *contents;
+static bfd_boolean
+srec_read_section (bfd *abfd, asection *section, bfd_byte *contents)

 {
   int c;
   bfd_size_type sofar = 0;
 {
   int c;
   bfd_size_type sofar = 0;

-  boolean error = false;
+  bfd_boolean error = FALSE;

   bfd_byte *buf = NULL;
   size_t bufsize = 0;
 
   bfd_byte *buf = NULL;
   size_t bufsize = 0;
 


@@ -735,7 +739,7 @@ srec_read_section (abfd, section, contents)
        continue;
 
       /* This is called after srec_scan has already been called, so we
        continue;
 
       /* 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_bread (hdr, (bfd_size_type) 3, abfd) != 3)
       BFD_ASSERT (c == 'S');
 
       if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)


@@ -763,10 +767,10 @@ srec_read_section (abfd, section, contents)
       switch (hdr[0])
        {
        default:
       switch (hdr[0])
        {
        default:

-         BFD_ASSERT (sofar == section->_raw_size);
+         BFD_ASSERT (sofar == section->size);

          if (buf != NULL)
            free (buf);
          if (buf != NULL)
            free (buf);

-         return true;
+         return TRUE;

 
        case '3':
          address = HEX (data);
 
        case '3':
          address = HEX (data);


@@ -788,10 +792,10 @@ srec_read_section (abfd, section, contents)
          if (address != section->vma + sofar)
            {
              /* We've come to the end of this section.  */
          if (address != section->vma + sofar)
            {
              /* We've come to the end of this section.  */

-             BFD_ASSERT (sofar == section->_raw_size);
+             BFD_ASSERT (sofar == section->size);

              if (buf != NULL)
                free (buf);
              if (buf != NULL)
                free (buf);

-             return true;
+             return TRUE;

            }
 
          /* Don't consider checksum.  */
            }
 
          /* Don't consider checksum.  */


@@ -811,78 +815,83 @@ srec_read_section (abfd, section, contents)
   if (error)
     goto error_return;
 
   if (error)
     goto error_return;
 

-  BFD_ASSERT (sofar == section->_raw_size);
+  BFD_ASSERT (sofar == section->size);

 
   if (buf != NULL)
     free (buf);
 
 
   if (buf != NULL)
     free (buf);
 

-  return true;
+  return TRUE;

 
  error_return:
   if (buf != NULL)
     free (buf);
 
  error_return:
   if (buf != NULL)
     free (buf);

-  return false;
+  return FALSE;

 }
 
 /* Get the contents of a section in an S-record file.  */
 
 }
 
 /* Get the contents of a section in an S-record file.  */
 

-static boolean
-srec_get_section_contents (abfd, section, location, offset, count)
-     bfd *abfd;
-     asection *section;
-     PTR location;
-     file_ptr offset;
-     bfd_size_type count;
+static bfd_boolean
+srec_get_section_contents (bfd *abfd,
+                          asection *section,
+                          void * location,
+                          file_ptr offset,
+                          bfd_size_type count)

 {
 {

+  if (count == 0)
+    return TRUE;
+
+  if (offset + count < count
+      || offset + count > section->size)
+    {
+      bfd_set_error (bfd_error_invalid_operation);
+      return FALSE;
+    }
+

   if (section->used_by_bfd == NULL)
     {
   if (section->used_by_bfd == NULL)
     {

-      section->used_by_bfd = bfd_alloc (abfd, section->_raw_size);
-      if (section->used_by_bfd == NULL && section->_raw_size != 0)
-       return false;
+      section->used_by_bfd = bfd_alloc (abfd, section->size);
+      if (section->used_by_bfd == NULL)
+       return FALSE;

 
 

-      if (! srec_read_section (abfd, section, section->used_by_bfd))
-       return false;
+      if (! srec_read_section (abfd, section,
+                              (bfd_byte *) section->used_by_bfd))
+       return FALSE;

     }
 
   memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
          (size_t) 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.  */
 
 }
 
 /* Set the architecture.  We accept an unknown architecture here.  */
 

-static boolean
-srec_set_arch_mach (abfd, arch, mach)
-     bfd *abfd;
-     enum bfd_architecture arch;
-     unsigned long mach;
+static bfd_boolean
+srec_set_arch_mach (bfd *abfd, enum bfd_architecture arch, unsigned long mach)

 {
 {

-  if (arch == bfd_arch_unknown)
-    {
-      abfd->arch_info = &bfd_default_arch_struct;
-      return true;
-    }
-  return bfd_default_set_arch_mach (abfd, arch, mach);
+  if (arch != bfd_arch_unknown)
+    return bfd_default_set_arch_mach (abfd, arch, mach);
+
+  abfd->arch_info = & bfd_default_arch_struct;
+  return TRUE;

 }
 
 /* We have to save up all the Srecords for a splurge before output.  */
 
 }
 
 /* We have to save up all the Srecords for a splurge before output.  */
 

-static boolean
-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;
+static bfd_boolean
+srec_set_section_contents (bfd *abfd,
+                          sec_ptr section,
+                          const void * location,
+                          file_ptr offset,
+                          bfd_size_type bytes_to_do)

 {
 {

+  int opb = bfd_octets_per_byte (abfd, NULL);

   tdata_type *tdata = abfd->tdata.srec_data;
   tdata_type *tdata = abfd->tdata.srec_data;

-  register srec_data_list_type *entry;
+  srec_data_list_type *entry;

 
 

-  entry = ((srec_data_list_type *)
-          bfd_alloc (abfd, (bfd_size_type) sizeof (srec_data_list_type)));
+  entry = (srec_data_list_type *) bfd_alloc (abfd, sizeof (* entry));

   if (entry == NULL)
   if (entry == NULL)

-    return false;
+    return FALSE;

 
   if (bytes_to_do
       && (section->flags & SEC_ALLOC)
 
   if (bytes_to_do
       && (section->flags & SEC_ALLOC)


@@ -892,27 +901,27 @@ srec_set_section_contents (abfd, section, location, offset, bytes_to_do)
 
       data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do);
       if (data == NULL)
 
       data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do);
       if (data == NULL)

-       return false;
-      memcpy ((PTR) data, location, (size_t) bytes_to_do);
+       return FALSE;
+      memcpy ((void *) 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)
+      /* If _bfd_srec_forceS3 is TRUE then always select S3 records,
+        regardless of the size of the addresses.  */
+      if (_bfd_srec_forceS3)

        tdata->type = 3;
        tdata->type = 3;

-      else if ((section->lma + offset + bytes_to_do - 1) <= 0xffff)
+      else if ((section->lma + (offset + bytes_to_do) / opb - 1) <= 0xffff)

        ;  /* The default, S1, is OK.  */
        ;  /* The default, S1, is OK.  */

-      else if ((section->lma + offset + bytes_to_do - 1) <= 0xffffff
+      else if ((section->lma + (offset + bytes_to_do) / opb - 1) <= 0xffffff

               && tdata->type <= 2)
        tdata->type = 2;
       else
        tdata->type = 3;
 
       entry->data = data;
               && tdata->type <= 2)
        tdata->type = 2;
       else
        tdata->type = 3;
 
       entry->data = data;

-      entry->where = section->lma + offset;
+      entry->where = section->lma + offset / opb;

       entry->size = bytes_to_do;
 
       /* Sort the records by address.  Optimize for the common case of
       entry->size = bytes_to_do;
 
       /* 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)
        {
       if (tdata->tail != NULL
          && entry->where >= tdata->tail->where)
        {


@@ -922,7 +931,7 @@ srec_set_section_contents (abfd, section, location, offset, bytes_to_do)
        }
       else
        {
        }
       else
        {

-         register srec_data_list_type **look;
+         srec_data_list_type **look;

 
          for (look = &tdata->head;
               *look != NULL && (*look)->where < entry->where;
 
          for (look = &tdata->head;
               *look != NULL && (*look)->where < entry->where;


@@ -934,20 +943,19 @@ srec_set_section_contents (abfd, section, location, offset, bytes_to_do)
            tdata->tail = entry;
        }
     }
            tdata->tail = entry;
        }
     }

-  return true;
+  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.  */
 
 }
 
 /* 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 boolean
-srec_write_record (abfd, type, address, data, end)
-     bfd *abfd;
-     unsigned int type;
-     bfd_vma address;
-     const bfd_byte *data;
-     const bfd_byte *end;
+static bfd_boolean
+srec_write_record (bfd *abfd,
+                  unsigned int type,
+                  bfd_vma address,
+                  const bfd_byte *data,
+                  const bfd_byte *end)

 {
   char buffer[2 * MAXCHUNK + 6];
   unsigned int check_sum = 0;
 {
   char buffer[2 * MAXCHUNK + 6];
   unsigned int check_sum = 0;


@@ -968,10 +976,12 @@ srec_write_record (abfd, type, address, data, end)
     case 7:
       TOHEX (dst, (address >> 24), check_sum);
       dst += 2;
     case 7:
       TOHEX (dst, (address >> 24), check_sum);
       dst += 2;

+      /* Fall through.  */

     case 8:
     case 2:
       TOHEX (dst, (address >> 16), check_sum);
       dst += 2;
     case 8:
     case 2:
       TOHEX (dst, (address >> 16), check_sum);
       dst += 2;

+      /* Fall through.  */

     case 9:
     case 1:
     case 0:
     case 9:
     case 1:
     case 0:


@@ -998,30 +1008,28 @@ srec_write_record (abfd, type, address, data, end)
   *dst++ = '\r';
   *dst++ = '\n';
   wrlen = dst - buffer;
   *dst++ = '\r';
   *dst++ = '\n';
   wrlen = dst - buffer;

-  if (bfd_bwrite ((PTR) buffer, wrlen, abfd) != wrlen)
-    return false;
-  return true;
+
+  return bfd_bwrite ((void *) buffer, wrlen, abfd) == wrlen;

 }
 
 }
 

-static boolean
-srec_write_header (abfd)
-     bfd *abfd;
+static bfd_boolean
+srec_write_header (bfd *abfd)

 {
   unsigned int len = strlen (abfd->filename);
 
 {
   unsigned int len = strlen (abfd->filename);
 

-  /* I'll put an arbitary 40 char limit on header size.  */
+  /* I'll put an arbitrary 40 char limit on header size.  */

   if (len > 40)
     len = 40;
 
   return srec_write_record (abfd, 0, (bfd_vma) 0,
   if (len > 40)
     len = 40;
 
   return srec_write_record (abfd, 0, (bfd_vma) 0,

-                           abfd->filename, abfd->filename + len);
+                           (bfd_byte *) abfd->filename,
+                           (bfd_byte *) abfd->filename + len);

 }
 
 }
 

-static boolean
-srec_write_section (abfd, tdata, list)
-     bfd *abfd;
-     tdata_type *tdata;
-     srec_data_list_type *list;
+static bfd_boolean
+srec_write_section (bfd *abfd,
+                   tdata_type *tdata,
+                   srec_data_list_type *list)

 {
   unsigned int octets_written = 0;
   bfd_byte *location = list->data;
 {
   unsigned int octets_written = 0;
   bfd_byte *location = list->data;


@@ -1032,47 +1040,45 @@ srec_write_section (abfd, tdata, list)
      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.  */
      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;
+  if (_bfd_srec_len == 0)
+    _bfd_srec_len = 1;
+  else if (_bfd_srec_len > MAXCHUNK - tdata->type - 2)
+    _bfd_srec_len = MAXCHUNK - tdata->type - 2;

 
   while (octets_written < list->size)
     {
       bfd_vma address;
       unsigned int octets_this_chunk = list->size - octets_written;
 
 
   while (octets_written < list->size)
     {
       bfd_vma address;
       unsigned int octets_this_chunk = list->size - octets_written;
 

-      if (octets_this_chunk > Chunk)
-       octets_this_chunk = Chunk;
+      if (octets_this_chunk > _bfd_srec_len)
+       octets_this_chunk = _bfd_srec_len;

 
 

-      address = list->where + octets_written / bfd_octets_per_byte (abfd);
+      address = list->where + (octets_written
+                              / bfd_octets_per_byte (abfd, NULL));

 
       if (! srec_write_record (abfd,
                               tdata->type,
                               address,
                               location,
                               location + octets_this_chunk))
 
       if (! srec_write_record (abfd,
                               tdata->type,
                               address,
                               location,
                               location + octets_this_chunk))

-       return false;
+       return FALSE;

 
       octets_written += octets_this_chunk;
       location += octets_this_chunk;
     }
 
 
       octets_written += octets_this_chunk;
       location += octets_this_chunk;
     }
 

-  return true;
+  return TRUE;

 }
 
 }
 

-static boolean
-srec_write_terminator (abfd, tdata)
-     bfd *abfd;
-     tdata_type *tdata;
+static bfd_boolean
+srec_write_terminator (bfd *abfd, tdata_type *tdata)

 {
   return srec_write_record (abfd, 10 - tdata->type,
                            abfd->start_address, NULL, NULL);
 }
 
 {
   return srec_write_record (abfd, 10 - tdata->type,
                            abfd->start_address, NULL, NULL);
 }
 

-static boolean
-srec_write_symbols (abfd)
-     bfd *abfd;
+static bfd_boolean
+srec_write_symbols (bfd *abfd)

 {
   /* Dump out the symbols of a bfd.  */
   int i;
 {
   /* Dump out the symbols of a bfd.  */
   int i;


@@ -1082,11 +1088,12 @@ srec_write_symbols (abfd)
     {
       bfd_size_type len;
       asymbol **table = bfd_get_outsymbols (abfd);
     {
       bfd_size_type len;
       asymbol **table = bfd_get_outsymbols (abfd);

+

       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)
       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;
+       return FALSE;

 
       for (i = 0; i < count; i++)
        {
 
       for (i = 0; i < count; i++)
        {


@@ -1095,39 +1102,38 @@ srec_write_symbols (abfd)
              && (s->flags & BSF_DEBUGGING) == 0)
            {
              /* Just dump out non debug symbols.  */
              && (s->flags & BSF_DEBUGGING) == 0)
            {
              /* Just dump out non debug symbols.  */

-             char buf[42], *p;
+             char buf[43], *p;

 
              len = strlen (s->name);
              if (bfd_bwrite ("  ", (bfd_size_type) 2, abfd) != 2
                  || bfd_bwrite (s->name, len, abfd) != len)
 
              len = strlen (s->name);
              if (bfd_bwrite ("  ", (bfd_size_type) 2, abfd) != 2
                  || bfd_bwrite (s->name, len, abfd) != len)

-               return false;
+               return FALSE;

 
 

-             sprintf_vma (buf + 1, (s->value
+             sprintf_vma (buf + 2, (s->value

                                     + s->section->output_section->lma
                                     + s->section->output_offset));
                                     + s->section->output_section->lma
                                     + s->section->output_offset));

-             p = buf + 1;
+             p = buf + 2;

              while (p[0] == '0' && p[1] != 0)
                p++;
              len = strlen (p);
              p[len] = '\r';
              p[len + 1] = '\n';
              while (p[0] == '0' && p[1] != 0)
                p++;
              len = strlen (p);
              p[len] = '\r';
              p[len + 1] = '\n';

+             *--p = '$';

              *--p = ' ';
              *--p = ' ';

-             len += 3;
+             len += 4;

              if (bfd_bwrite (p, len, abfd) != len)
              if (bfd_bwrite (p, len, abfd) != len)

-               return false;
+               return FALSE;

            }
        }
       if (bfd_bwrite ("$$ \r\n", (bfd_size_type) 5, abfd) != 5)
            }
        }
       if (bfd_bwrite ("$$ \r\n", (bfd_size_type) 5, abfd) != 5)

-       return false;
+       return FALSE;

     }
 
     }
 

-  return true;
+  return TRUE;

 }
 
 }
 

-static boolean
-internal_srec_write_object_contents (abfd, symbols)
-     bfd *abfd;
-     int symbols;
+static bfd_boolean
+internal_srec_write_object_contents (bfd *abfd, int symbols)

 {
   tdata_type *tdata = abfd->tdata.srec_data;
   srec_data_list_type *list;
 {
   tdata_type *tdata = abfd->tdata.srec_data;
   srec_data_list_type *list;


@@ -1135,11 +1141,11 @@ internal_srec_write_object_contents (abfd, symbols)
   if (symbols)
     {
       if (! srec_write_symbols (abfd))
   if (symbols)
     {
       if (! srec_write_symbols (abfd))

-       return false;
+       return FALSE;

     }
 
   if (! srec_write_header (abfd))
     }
 
   if (! srec_write_header (abfd))

-    return false;
+    return FALSE;

 
   /* Now wander though all the sections provided and output them.  */
   list = tdata->head;
 
   /* Now wander though all the sections provided and output them.  */
   list = tdata->head;


@@ -1147,30 +1153,27 @@ internal_srec_write_object_contents (abfd, symbols)
   while (list != (srec_data_list_type *) NULL)
     {
       if (! srec_write_section (abfd, tdata, list))
   while (list != (srec_data_list_type *) NULL)
     {
       if (! srec_write_section (abfd, tdata, list))

-       return false;
+       return FALSE;

       list = list->next;
     }
   return srec_write_terminator (abfd, tdata);
 }
 
       list = list->next;
     }
   return srec_write_terminator (abfd, tdata);
 }
 

-static boolean
-srec_write_object_contents (abfd)
-     bfd *abfd;
+static bfd_boolean
+srec_write_object_contents (bfd *abfd)

 {
   return internal_srec_write_object_contents (abfd, 0);
 }
 
 {
   return internal_srec_write_object_contents (abfd, 0);
 }
 

-static boolean
-symbolsrec_write_object_contents (abfd)
-     bfd *abfd;
+static bfd_boolean
+symbolsrec_write_object_contents (bfd *abfd)

 {
   return internal_srec_write_object_contents (abfd, 1);
 }
 
 static int
 {
   return internal_srec_write_object_contents (abfd, 1);
 }
 
 static int

-srec_sizeof_headers (abfd, exec)
-     bfd *abfd ATTRIBUTE_UNUSED;
-     boolean exec ATTRIBUTE_UNUSED;
+srec_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
+                    struct bfd_link_info *info ATTRIBUTE_UNUSED)

 {
   return 0;
 }
 {
   return 0;
 }


@@ -1178,8 +1181,7 @@ srec_sizeof_headers (abfd, exec)
 /* Return the amount of memory needed to read the symbol table.  */
 
 static long
 /* 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 (bfd *abfd)

 {
   return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *);
 }
 {
   return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *);
 }


@@ -1187,23 +1189,21 @@ srec_get_symtab_upper_bound (abfd)
 /* Return the symbol table.  */
 
 static long
 /* Return the symbol table.  */
 
 static long

-srec_get_symtab (abfd, alocation)
-     bfd *abfd;
-     asymbol **alocation;
+srec_canonicalize_symtab (bfd *abfd, asymbol **alocation)

 {
   bfd_size_type symcount = bfd_get_symcount (abfd);
   asymbol *csymbols;
   unsigned int i;
 
   csymbols = abfd->tdata.srec_data->csymbols;
 {
   bfd_size_type symcount = bfd_get_symcount (abfd);
   asymbol *csymbols;
   unsigned int i;
 
   csymbols = abfd->tdata.srec_data->csymbols;

-  if (csymbols == NULL)
+  if (csymbols == NULL && symcount != 0)

     {
       asymbol *c;
       struct srec_symbol *s;
 
       csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));
     {
       asymbol *c;
       struct srec_symbol *s;
 
       csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));

-      if (csymbols == NULL && symcount != 0)
-       return false;
+      if (csymbols == NULL)
+       return -1;

       abfd->tdata.srec_data->csymbols = csymbols;
 
       for (s = abfd->tdata.srec_data->symbols, c = csymbols;
       abfd->tdata.srec_data->csymbols = csymbols;
 
       for (s = abfd->tdata.srec_data->symbols, c = csymbols;


@@ -1227,108 +1227,108 @@ srec_get_symtab (abfd, alocation)
 }
 
 static void
 }
 
 static void

-srec_get_symbol_info (ignore_abfd, symbol, ret)
-     bfd *ignore_abfd ATTRIBUTE_UNUSED;
-     asymbol *symbol;
-     symbol_info *ret;
+srec_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
+                     asymbol *symbol,
+                     symbol_info *ret)

 {
   bfd_symbol_info (symbol, ret);
 }
 
 static void
 {
   bfd_symbol_info (symbol, ret);
 }
 
 static void

-srec_print_symbol (abfd, afile, symbol, how)
-     bfd *abfd;
-     PTR afile;
-     asymbol *symbol;
-     bfd_print_symbol_type how;
+srec_print_symbol (bfd *abfd,
+                  void * afile,
+                  asymbol *symbol,
+                  bfd_print_symbol_type how)

 {
   FILE *file = (FILE *) afile;
 {
   FILE *file = (FILE *) afile;

+

   switch (how)
     {
     case bfd_print_symbol_name:
       fprintf (file, "%s", symbol->name);
       break;
     default:
   switch (how)
     {
     case bfd_print_symbol_name:
       fprintf (file, "%s", symbol->name);
       break;
     default:

-      bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
+      bfd_print_symbol_vandf (abfd, (void *) file, symbol);

       fprintf (file, " %-5s %s",
               symbol->section->name,
               symbol->name);
       fprintf (file, " %-5s %s",
               symbol->section->name,
               symbol->name);

-

     }
 }
 
     }
 }
 

-#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_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
-#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_get_section_contents_in_window \
-  _bfd_generic_get_section_contents_in_window
-
-#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_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
+#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_target_special_symbol        _bfd_bool_bfd_asymbol_false
+#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_find_line                           _bfd_nosymbols_find_line
+#define srec_find_inliner_info                   _bfd_nosymbols_find_inliner_info
+#define srec_make_empty_symbol                   _bfd_generic_make_empty_symbol
+#define srec_get_symbol_version_string           _bfd_nosymbols_get_symbol_version_string
+#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_section_contents_in_window      _bfd_generic_get_section_contents_in_window
+#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_gc_sections                     bfd_generic_gc_sections
+#define srec_bfd_lookup_section_flags            bfd_generic_lookup_section_flags
+#define srec_bfd_merge_sections                          bfd_generic_merge_sections
+#define srec_bfd_is_group_section                bfd_generic_is_group_section
+#define srec_bfd_group_name                      bfd_generic_group_name
+#define srec_bfd_discard_group                   bfd_generic_discard_group
+#define srec_section_already_linked              _bfd_generic_section_already_linked
+#define srec_bfd_define_common_symbol            bfd_generic_define_common_symbol
+#define srec_bfd_link_hide_symbol                _bfd_generic_link_hide_symbol
+#define srec_bfd_define_start_stop               bfd_generic_define_start_stop
+#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_link_just_syms                          _bfd_generic_link_just_syms
+#define srec_bfd_copy_link_hash_symbol_type      _bfd_generic_copy_link_hash_symbol_type
+#define srec_bfd_final_link                      _bfd_generic_final_link
+#define srec_bfd_link_split_section              _bfd_generic_link_split_section
+#define srec_bfd_link_check_relocs               _bfd_generic_link_check_relocs

 
 const bfd_target srec_vec =
 {
 
 const bfd_target srec_vec =
 {

-  "srec",                      /* name */
+  "srec",                      /* Name.  */

   bfd_target_srec_flavour,
   bfd_target_srec_flavour,

-  BFD_ENDIAN_UNKNOWN,          /* target byte order */
-  BFD_ENDIAN_UNKNOWN,          /* target headers byte order */
-  (HAS_RELOC | EXEC_P |                /* object flags */
+  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),
   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
    HAS_LINENO | HAS_DEBUG |
    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS

-   | SEC_ALLOC | SEC_LOAD | SEC_RELOC),        /* section flags */
-  0,                           /* leading underscore */
-  ' ',                         /* ar_pad_char */
-  16,                          /* ar_max_namelen */
+   | SEC_ALLOC | SEC_LOAD | SEC_RELOC),        /* Section flags.  */
+  0,                           /* Leading underscore.  */
+  ' ',                         /* AR_pad_char.  */
+  16,                          /* AR_max_namelen.  */
+  0,                           /* match priority.  */

   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
   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_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_getb64, bfd_getb_signed_64, bfd_putb64,
   bfd_getb32, bfd_getb_signed_32, bfd_putb32,

-  bfd_getb16, bfd_getb_signed_16, bfd_putb16,  /* hdrs */
+  bfd_getb16, bfd_getb_signed_16, bfd_putb16,  /* Hdrs.  */

 
   {
     _bfd_dummy_target,
 
   {
     _bfd_dummy_target,

-    srec_object_p,             /* bfd_check_format */
+    srec_object_p,             /* bfd_check_format.  */

     _bfd_dummy_target,
     _bfd_dummy_target,
   },
   {
     _bfd_dummy_target,
     _bfd_dummy_target,
   },
   {

-    bfd_false,
+    _bfd_bool_bfd_false_error,

     srec_mkobject,
     _bfd_generic_mkarchive,
     srec_mkobject,
     _bfd_generic_mkarchive,

-    bfd_false,
+    _bfd_bool_bfd_false_error,

   },
   },

-  {                            /* bfd_write_contents */
-    bfd_false,
+  {                            /* bfd_write_contents.  */
+    _bfd_bool_bfd_false_error,

     srec_write_object_contents,
     _bfd_write_archive_contents,
     srec_write_object_contents,
     _bfd_write_archive_contents,

-    bfd_false,
+    _bfd_bool_bfd_false_error,

   },
 
   BFD_JUMP_TABLE_GENERIC (srec),
   },
 
   BFD_JUMP_TABLE_GENERIC (srec),


@@ -1336,54 +1336,55 @@ const bfd_target srec_vec =
   BFD_JUMP_TABLE_CORE (_bfd_nocore),
   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
   BFD_JUMP_TABLE_SYMBOLS (srec),
   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_RELOCS (_bfd_norelocs),

   BFD_JUMP_TABLE_WRITE (srec),
   BFD_JUMP_TABLE_LINK (srec),
   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 
   NULL,
 
   BFD_JUMP_TABLE_WRITE (srec),
   BFD_JUMP_TABLE_LINK (srec),
   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 
   NULL,
 

-  (PTR) 0
+  NULL

 };
 
 const bfd_target symbolsrec_vec =
 {
 };
 
 const bfd_target symbolsrec_vec =
 {

-  "symbolsrec",                        /* name */
+  "symbolsrec",                        /* Name.  */

   bfd_target_srec_flavour,
   bfd_target_srec_flavour,

-  BFD_ENDIAN_UNKNOWN,          /* target byte order */
-  BFD_ENDIAN_UNKNOWN,          /* target headers byte order */
-  (HAS_RELOC | EXEC_P |                /* object flags */
+  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),
   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
    HAS_LINENO | HAS_DEBUG |
    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS

-   | SEC_ALLOC | SEC_LOAD | SEC_RELOC),        /* section flags */
-  0,                           /* leading underscore */
-  ' ',                         /* ar_pad_char */
-  16,                          /* ar_max_namelen */
+   | SEC_ALLOC | SEC_LOAD | SEC_RELOC),        /* Section flags.  */
+  0,                           /* Leading underscore.  */
+  ' ',                         /* AR_pad_char.  */
+  16,                          /* AR_max_namelen.  */
+  0,                           /* match priority.  */

   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
   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_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_getb64, bfd_getb_signed_64, bfd_putb64,
   bfd_getb32, bfd_getb_signed_32, bfd_putb32,

-  bfd_getb16, bfd_getb_signed_16, bfd_putb16,  /* hdrs */
+  bfd_getb16, bfd_getb_signed_16, bfd_putb16,  /* Headers.  */

 
   {
     _bfd_dummy_target,
 
   {
     _bfd_dummy_target,

-    symbolsrec_object_p,       /* bfd_check_format */
+    symbolsrec_object_p,       /* bfd_check_format.  */

     _bfd_dummy_target,
     _bfd_dummy_target,
   },
   {
     _bfd_dummy_target,
     _bfd_dummy_target,
   },
   {

-    bfd_false,
+    _bfd_bool_bfd_false_error,

     srec_mkobject,
     _bfd_generic_mkarchive,
     srec_mkobject,
     _bfd_generic_mkarchive,

-    bfd_false,
+    _bfd_bool_bfd_false_error,

   },
   },

-  {                            /* bfd_write_contents */
-    bfd_false,
+  {                            /* bfd_write_contents.  */
+    _bfd_bool_bfd_false_error,

     symbolsrec_write_object_contents,
     _bfd_write_archive_contents,
     symbolsrec_write_object_contents,
     _bfd_write_archive_contents,

-    bfd_false,
+    _bfd_bool_bfd_false_error,

   },
 
   BFD_JUMP_TABLE_GENERIC (srec),
   },
 
   BFD_JUMP_TABLE_GENERIC (srec),


@@ -1391,12 +1392,12 @@ const bfd_target symbolsrec_vec =
   BFD_JUMP_TABLE_CORE (_bfd_nocore),
   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
   BFD_JUMP_TABLE_SYMBOLS (srec),
   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_RELOCS (_bfd_norelocs),

   BFD_JUMP_TABLE_WRITE (srec),
   BFD_JUMP_TABLE_LINK (srec),
   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 
   NULL,
 
   BFD_JUMP_TABLE_WRITE (srec),
   BFD_JUMP_TABLE_LINK (srec),
   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 
   NULL,
 

-  (PTR) 0
+  NULL

 };
 };