* config/tc-xtensa.h (resource_table): Change units to unsigned chars.
[deliverable/binutils-gdb.git] / bfd / nlmcode.h
index c3d6bca6b15e673c2a401036955a70458679ef5e..4773061138fa91b4283f3e876ac6a5540bd9547e 100644 (file)
@@ -1,6 +1,6 @@
 /* NLM (NetWare Loadable Module) executable support for BFD.
 /* NLM (NetWare Loadable Module) executable support for BFD.
-   Copyright 1993, 1994, 1995, 1998, 2000, 2001, 2002, 2003, 2004
-   Free Software Foundation, Inc.
+   Copyright 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+   2005 Free Software Foundation, Inc.
 
    Written by Fred Fish @ Cygnus Support, using ELF support as the
    template.
 
    Written by Fred Fish @ Cygnus Support, using ELF support as the
    template.
@@ -19,7 +19,7 @@
 
    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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
 
 #include "bfd.h"
 #include "sysdep.h"
 
 #include "bfd.h"
 #include "sysdep.h"
    is named nlm_symbol_type below is actually named nlm32_symbol_type
    in the final executable.  */
 
    is named nlm_symbol_type below is actually named nlm32_symbol_type
    in the final executable.  */
 
-#define Nlm_External_Fixed_Header      NlmNAME(External_Fixed_Header)
-#define Nlm_External_Version_Header    NlmNAME(External_Version_Header)
-#define Nlm_External_Copyright_Header  NlmNAME(External_Copyright_Header)
-#define Nlm_External_Extended_Header   NlmNAME(External_Extended_Header)
-#define Nlm_External_Custom_Header     NlmNAME(External_Custom_Header)
-#define Nlm_External_Cygnus_Ext_Header NlmNAME(External_Cygnus_Ext_Header)
-
-#define nlm_symbol_type                        nlmNAME(symbol_type)
-#define nlm_get_symtab_upper_bound     nlmNAME(get_symtab_upper_bound)
-#define nlm_canonicalize_symtab                nlmNAME(canonicalize_symtab)
-#define nlm_make_empty_symbol          nlmNAME(make_empty_symbol)
-#define nlm_print_symbol               nlmNAME(print_symbol)
-#define nlm_get_symbol_info            nlmNAME(get_symbol_info)
-#define nlm_get_reloc_upper_bound      nlmNAME(get_reloc_upper_bound)
-#define nlm_canonicalize_reloc         nlmNAME(canonicalize_reloc)
-#define nlm_object_p                   nlmNAME(object_p)
-#define nlm_set_section_contents       nlmNAME(set_section_contents)
-#define nlm_write_object_contents      nlmNAME(write_object_contents)
+#define Nlm_External_Fixed_Header      NlmNAME (External_Fixed_Header)
+#define Nlm_External_Version_Header    NlmNAME (External_Version_Header)
+#define Nlm_External_Copyright_Header  NlmNAME (External_Copyright_Header)
+#define Nlm_External_Extended_Header   NlmNAME (External_Extended_Header)
+#define Nlm_External_Custom_Header     NlmNAME (External_Custom_Header)
+#define Nlm_External_Cygnus_Ext_Header NlmNAME (External_Cygnus_Ext_Header)
+
+#define nlm_symbol_type                        nlmNAME (symbol_type)
+#define nlm_get_symtab_upper_bound     nlmNAME (get_symtab_upper_bound)
+#define nlm_canonicalize_symtab                nlmNAME (canonicalize_symtab)
+#define nlm_make_empty_symbol          nlmNAME (make_empty_symbol)
+#define nlm_print_symbol               nlmNAME (print_symbol)
+#define nlm_get_symbol_info            nlmNAME (get_symbol_info)
+#define nlm_get_reloc_upper_bound      nlmNAME (get_reloc_upper_bound)
+#define nlm_canonicalize_reloc         nlmNAME (canonicalize_reloc)
+#define nlm_object_p                   nlmNAME (object_p)
+#define nlm_set_section_contents       nlmNAME (set_section_contents)
+#define nlm_write_object_contents      nlmNAME (write_object_contents)
 
 #define nlm_swap_fixed_header_in(abfd,src,dst) \
 
 #define nlm_swap_fixed_header_in(abfd,src,dst) \
-  (nlm_swap_fixed_header_in_func(abfd)) (abfd,src,dst)
+  (nlm_swap_fixed_header_in_func (abfd)) (abfd, src, dst)
 #define nlm_swap_fixed_header_out(abfd,src,dst) \
 #define nlm_swap_fixed_header_out(abfd,src,dst) \
-  (nlm_swap_fixed_header_out_func(abfd)) (abfd,src,dst)
-
-/* Forward declarations of static functions.  */
-
-static bfd_boolean add_bfd_section
-  PARAMS ((bfd *, char *, file_ptr, bfd_size_type, flagword));
-static bfd_boolean nlm_swap_variable_header_in
-  PARAMS ((bfd *));
-static bfd_boolean nlm_swap_variable_header_out
-  PARAMS ((bfd *));
-static bfd_boolean find_nonzero
-  PARAMS ((PTR, size_t));
-static bfd_boolean nlm_swap_auxiliary_headers_in
-  PARAMS ((bfd *));
-static bfd_boolean nlm_swap_auxiliary_headers_out
-  PARAMS ((bfd *));
-static bfd_boolean nlm_slurp_symbol_table
-  PARAMS ((bfd *));
-static bfd_boolean nlm_slurp_reloc_fixups
-  PARAMS ((bfd *));
-static bfd_boolean nlm_compute_section_file_positions
-  PARAMS ((bfd *));
-static int nlm_external_reloc_compare
-  PARAMS ((const void *, const void *));
+  (nlm_swap_fixed_header_out_func (abfd)) (abfd, src, dst)
 
 /* Should perhaps use put_offset, put_word, etc.  For now, the two versions
    can be handled by explicitly specifying 32 bits or "the long type".  */
 
 /* Should perhaps use put_offset, put_word, etc.  For now, the two versions
    can be handled by explicitly specifying 32 bits or "the long type".  */
@@ -91,284 +68,86 @@ static int nlm_external_reloc_compare
 #define get_word       H_GET_32
 #endif
 
 #define get_word       H_GET_32
 #endif
 
-const bfd_target *
-nlm_object_p (abfd)
-     bfd *abfd;
-{
-  struct nlm_obj_tdata *preserved_tdata = nlm_tdata (abfd);
-  bfd_boolean (*backend_object_p) PARAMS ((bfd *));
-  PTR x_fxdhdr = NULL;
-  Nlm_Internal_Fixed_Header *i_fxdhdrp;
-  struct nlm_obj_tdata *new_tdata = NULL;
-  const char *signature;
-  enum bfd_architecture arch;
-  bfd_size_type amt;
-
-  /* Some NLM formats have a prefix before the standard NLM fixed
-     header.  */
-  backend_object_p = nlm_backend_object_p_func (abfd);
-  if (backend_object_p)
-    {
-      if (!(*backend_object_p) (abfd))
-       goto got_wrong_format_error;
-    }
-
-  /* Read in the fixed length portion of the NLM header in external format.  */
-  amt = nlm_fixed_header_size (abfd);
-  x_fxdhdr = (PTR) bfd_malloc (amt);
-  if (x_fxdhdr == NULL)
-    goto got_no_match;
-
-  if (bfd_bread ((PTR) x_fxdhdr, amt, abfd) != amt)
-    {
-      if (bfd_get_error () != bfd_error_system_call)
-       goto got_wrong_format_error;
-      else
-       goto got_no_match;
-    }
-
-  /* Allocate an instance of the nlm_obj_tdata structure and hook it up to
-     the tdata pointer in the bfd.  */
-  amt = sizeof (struct nlm_obj_tdata);
-  new_tdata = (struct nlm_obj_tdata *) bfd_zalloc (abfd, amt);
-  if (new_tdata == NULL)
-    goto got_no_match;
-
-  nlm_tdata (abfd) = new_tdata;
-
-  i_fxdhdrp = nlm_fixed_header (abfd);
-  nlm_swap_fixed_header_in (abfd, x_fxdhdr, i_fxdhdrp);
-  free (x_fxdhdr);
-  x_fxdhdr = NULL;
-
-  /* Check to see if we have an NLM file for this backend by matching
-     the NLM signature.  */
-  signature = nlm_signature (abfd);
-  if (signature != NULL
-      && *signature != '\0'
-      && strncmp ((char *) i_fxdhdrp->signature, signature,
-                 NLM_SIGNATURE_SIZE) != 0)
-    goto got_wrong_format_error;
-
-  /* There's no supported way to discover the endianess of an NLM, so test for
-     a sane version number after doing byte swapping appropriate for this
-     XVEC.  (Hack alert!)  */
-  if (i_fxdhdrp->version > 0xFFFF)
-    goto got_wrong_format_error;
-
-  /* There's no supported way to check for 32 bit versus 64 bit addresses,
-     so ignore this distinction for now.  (FIXME) */
-  /* Swap in the rest of the required header.  */
-  if (!nlm_swap_variable_header_in (abfd))
-    {
-      if (bfd_get_error () != bfd_error_system_call)
-       goto got_wrong_format_error;
-      else
-       goto got_no_match;
-    }
-
-  /* Add the sections supplied by all NLM's, and then read in the
-     auxiliary headers.  Reading the auxiliary headers may create
-     additional sections described in the cygnus_ext header.
-     From this point on we assume that we have an NLM, and do not
-     treat errors as indicating the wrong format.  */
-  if (!add_bfd_section (abfd, NLM_CODE_NAME,
-                       i_fxdhdrp->codeImageOffset,
-                       i_fxdhdrp->codeImageSize,
-                       (SEC_CODE | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
-                        | SEC_RELOC))
-      || !add_bfd_section (abfd, NLM_INITIALIZED_DATA_NAME,
-                          i_fxdhdrp->dataImageOffset,
-                          i_fxdhdrp->dataImageSize,
-                          (SEC_DATA | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
-                           | SEC_RELOC))
-      || !add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
-                          (file_ptr) 0,
-                          i_fxdhdrp->uninitializedDataSize,
-                          SEC_ALLOC))
-    goto got_no_match;
-
-  if (!nlm_swap_auxiliary_headers_in (abfd))
-    goto got_no_match;
-
-  if (nlm_fixed_header (abfd)->numberOfRelocationFixups != 0
-      || nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
-    abfd->flags |= HAS_RELOC;
-  if (nlm_fixed_header (abfd)->numberOfPublics != 0
-      || nlm_fixed_header (abfd)->numberOfDebugRecords != 0
-      || nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
-    abfd->flags |= HAS_SYMS;
-
-  arch = nlm_architecture (abfd);
-  if (arch != bfd_arch_unknown)
-    bfd_default_set_arch_mach (abfd, arch, (unsigned long) 0);
-
-  abfd->flags |= EXEC_P;
-  bfd_get_start_address (abfd) = nlm_fixed_header (abfd)->codeStartOffset;
-
-  return (abfd->xvec);
-
-got_wrong_format_error:
-  bfd_set_error (bfd_error_wrong_format);
-got_no_match:
-  nlm_tdata (abfd) = preserved_tdata;
-  if (new_tdata != NULL)
-    bfd_release (abfd, new_tdata);
-  if (x_fxdhdr != NULL)
-    free (x_fxdhdr);
-  return (NULL);
-}
-
-/* Add a section to the bfd.  */
-
-static bfd_boolean
-add_bfd_section (abfd, name, offset, size, flags)
-     bfd *abfd;
-     char *name;
-     file_ptr offset;
-     bfd_size_type size;
-     flagword flags;
-{
-  asection *newsect;
-
-  newsect = bfd_make_section (abfd, name);
-  if (newsect == NULL)
-    return FALSE;
-
-  newsect->vma = 0;            /* NLM's are relocatable.  */
-  newsect->size = size;
-  newsect->filepos = offset;
-  newsect->flags = flags;
-  newsect->alignment_power = bfd_log2 ((bfd_vma) 0);   /* FIXME */
-
-  return TRUE;
-}
-
 /* Read and swap in the variable length header.  All the fields must
    exist in the NLM, and must exist in the order they are read here.  */
 
 static bfd_boolean
 /* Read and swap in the variable length header.  All the fields must
    exist in the NLM, and must exist in the order they are read here.  */
 
 static bfd_boolean
-nlm_swap_variable_header_in (abfd)
-     bfd *abfd;
+nlm_swap_variable_header_in (bfd *abfd)
 {
   unsigned char temp[NLM_TARGET_LONG_SIZE];
   bfd_size_type amt;
 
   /* Read the description length and text members.  */
 {
   unsigned char temp[NLM_TARGET_LONG_SIZE];
   bfd_size_type amt;
 
   /* Read the description length and text members.  */
-
   amt = sizeof (nlm_variable_header (abfd)->descriptionLength);
   amt = sizeof (nlm_variable_header (abfd)->descriptionLength);
-  if (bfd_bread ((PTR) &nlm_variable_header (abfd)->descriptionLength,
+  if (bfd_bread ((void *) &nlm_variable_header (abfd)->descriptionLength,
                amt, abfd) != amt)
     return FALSE;
   amt = nlm_variable_header (abfd)->descriptionLength + 1;
                amt, abfd) != amt)
     return FALSE;
   amt = nlm_variable_header (abfd)->descriptionLength + 1;
-  if (bfd_bread ((PTR) nlm_variable_header (abfd)->descriptionText,
+  if (bfd_bread ((void *) nlm_variable_header (abfd)->descriptionText,
                amt, abfd) != amt)
     return FALSE;
 
   /* Read and convert the stackSize field.  */
                amt, abfd) != amt)
     return FALSE;
 
   /* Read and convert the stackSize field.  */
-
   amt = sizeof (temp);
   amt = sizeof (temp);
-  if (bfd_bread ((PTR) temp, amt, abfd) != amt)
+  if (bfd_bread ((void *) temp, amt, abfd) != amt)
     return FALSE;
   nlm_variable_header (abfd)->stackSize = get_word (abfd, (bfd_byte *) temp);
 
   /* Read and convert the reserved field.  */
     return FALSE;
   nlm_variable_header (abfd)->stackSize = get_word (abfd, (bfd_byte *) temp);
 
   /* Read and convert the reserved field.  */
-
   amt = sizeof (temp);
   amt = sizeof (temp);
-  if (bfd_bread ((PTR) temp, amt, abfd) != amt)
+  if (bfd_bread ((void *) temp, amt, abfd) != amt)
     return FALSE;
   nlm_variable_header (abfd)->reserved = get_word (abfd, (bfd_byte *) temp);
 
   /* Read the oldThreadName field.  This field is a fixed length string.  */
     return FALSE;
   nlm_variable_header (abfd)->reserved = get_word (abfd, (bfd_byte *) temp);
 
   /* Read the oldThreadName field.  This field is a fixed length string.  */
-
   amt = sizeof (nlm_variable_header (abfd)->oldThreadName);
   amt = sizeof (nlm_variable_header (abfd)->oldThreadName);
-  if (bfd_bread ((PTR) nlm_variable_header (abfd)->oldThreadName,
+  if (bfd_bread ((void *) nlm_variable_header (abfd)->oldThreadName,
                amt, abfd) != amt)
     return FALSE;
 
   /* Read the screen name length and text members.  */
                amt, abfd) != amt)
     return FALSE;
 
   /* Read the screen name length and text members.  */
-
   amt = sizeof (nlm_variable_header (abfd)->screenNameLength);
   amt = sizeof (nlm_variable_header (abfd)->screenNameLength);
-  if (bfd_bread ((PTR) & nlm_variable_header (abfd)->screenNameLength,
+  if (bfd_bread ((void *) & nlm_variable_header (abfd)->screenNameLength,
                amt, abfd) != amt)
     return FALSE;
   amt = nlm_variable_header (abfd)->screenNameLength + 1;
                amt, abfd) != amt)
     return FALSE;
   amt = nlm_variable_header (abfd)->screenNameLength + 1;
-  if (bfd_bread ((PTR) nlm_variable_header (abfd)->screenName,
+  if (bfd_bread ((void *) nlm_variable_header (abfd)->screenName,
                amt, abfd) != amt)
     return FALSE;
 
   /* Read the thread name length and text members.  */
                amt, abfd) != amt)
     return FALSE;
 
   /* Read the thread name length and text members.  */
-
   amt = sizeof (nlm_variable_header (abfd)->threadNameLength);
   amt = sizeof (nlm_variable_header (abfd)->threadNameLength);
-  if (bfd_bread ((PTR) & nlm_variable_header (abfd)->threadNameLength,
+  if (bfd_bread ((void *) & nlm_variable_header (abfd)->threadNameLength,
                amt, abfd) != amt)
     return FALSE;
   amt = nlm_variable_header (abfd)->threadNameLength + 1;
                amt, abfd) != amt)
     return FALSE;
   amt = nlm_variable_header (abfd)->threadNameLength + 1;
-  if (bfd_bread ((PTR) nlm_variable_header (abfd)->threadName,
+  if (bfd_bread ((void *) nlm_variable_header (abfd)->threadName,
                amt, abfd) != amt)
     return FALSE;
   return TRUE;
 }
 
                amt, abfd) != amt)
     return FALSE;
   return TRUE;
 }
 
-/* Swap and write out the variable length header.  All the fields must
-   exist in the NLM, and must exist in this order.  */
+/* Add a section to the bfd.  */
 
 static bfd_boolean
 
 static bfd_boolean
-nlm_swap_variable_header_out (abfd)
-     bfd *abfd;
+add_bfd_section (bfd *abfd,
+                char *name,
+                file_ptr offset,
+                bfd_size_type size,
+                flagword flags)
 {
 {
-  unsigned char temp[NLM_TARGET_LONG_SIZE];
-  bfd_size_type amt;
-
-  /* Write the description length and text members.  */
-  amt = sizeof (nlm_variable_header (abfd)->descriptionLength);
-  if (bfd_bwrite ((PTR) & nlm_variable_header (abfd)->descriptionLength, amt,
-                abfd) != amt)
-    return FALSE;
-  amt = nlm_variable_header (abfd)->descriptionLength + 1;
-  if (bfd_bwrite ((PTR) nlm_variable_header (abfd)->descriptionText, amt,
-                abfd) != amt)
-    return FALSE;
-
-  /* Convert and write the stackSize field.  */
-  put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->stackSize,
-           (bfd_byte *) temp);
-  amt = sizeof (temp);
-  if (bfd_bwrite ((PTR) temp, amt, abfd) != amt)
-    return FALSE;
-
-  /* Convert and write the reserved field.  */
-  put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->reserved,
-           (bfd_byte *) temp);
-  amt = sizeof (temp);
-  if (bfd_bwrite ((PTR) temp, amt, abfd) != amt)
-    return FALSE;
+  asection *newsect;
 
 
-  /* Write the oldThreadName field.  This field is a fixed length string.  */
-  amt = sizeof (nlm_variable_header (abfd)->oldThreadName);
-  if (bfd_bwrite ((PTR) nlm_variable_header (abfd)->oldThreadName, amt,
-                abfd) != amt)
+  newsect = bfd_make_section (abfd, name);
+  if (newsect == NULL)
     return FALSE;
 
     return FALSE;
 
-  /* Write the screen name length and text members.  */
-  amt = sizeof (nlm_variable_header (abfd)->screenNameLength);
-  if (bfd_bwrite ((PTR) & nlm_variable_header (abfd)->screenNameLength, amt,
-                abfd) != amt)
-    return FALSE;
-  amt = nlm_variable_header (abfd)->screenNameLength + 1;
-  if (bfd_bwrite ((PTR) nlm_variable_header (abfd)->screenName, amt,
-                abfd) != amt)
-    return FALSE;
+  newsect->vma = 0;            /* NLM's are relocatable.  */
+  newsect->size = size;
+  newsect->filepos = offset;
+  newsect->flags = flags;
+  newsect->alignment_power = bfd_log2 ((bfd_vma) 0);   /* FIXME */
 
 
-  /* Write the thread name length and text members.  */
-  amt = sizeof (nlm_variable_header (abfd)->threadNameLength);
-  if (bfd_bwrite ((PTR) & nlm_variable_header (abfd)->threadNameLength, amt,
-                abfd) != amt)
-    return FALSE;
-  amt = nlm_variable_header (abfd)->threadNameLength + 1;
-  if (bfd_bwrite ((PTR) nlm_variable_header (abfd)->threadName, amt,
-                abfd) != amt)
-    return FALSE;
   return TRUE;
 }
 
   return TRUE;
 }
 
@@ -382,8 +161,7 @@ nlm_swap_variable_header_out (abfd)
    recognize it.  */
 
 static bfd_boolean
    recognize it.  */
 
 static bfd_boolean
-nlm_swap_auxiliary_headers_in (abfd)
-     bfd *abfd;
+nlm_swap_auxiliary_headers_in (bfd *abfd)
 {
   char tempstr[16];
   file_ptr position;
 {
   char tempstr[16];
   file_ptr position;
@@ -393,7 +171,7 @@ nlm_swap_auxiliary_headers_in (abfd)
     {
       position = bfd_tell (abfd);
       amt = sizeof (tempstr);
     {
       position = bfd_tell (abfd);
       amt = sizeof (tempstr);
-      if (bfd_bread ((PTR) tempstr, amt, abfd) != amt)
+      if (bfd_bread ((void *) tempstr, amt, abfd) != amt)
        return FALSE;
       if (bfd_seek (abfd, position, SEEK_SET) != 0)
        return FALSE;
        return FALSE;
       if (bfd_seek (abfd, position, SEEK_SET) != 0)
        return FALSE;
@@ -402,7 +180,7 @@ nlm_swap_auxiliary_headers_in (abfd)
          Nlm_External_Version_Header thdr;
 
          amt = sizeof (thdr);
          Nlm_External_Version_Header thdr;
 
          amt = sizeof (thdr);
-         if (bfd_bread ((PTR) &thdr, amt, abfd) != amt)
+         if (bfd_bread ((void *) &thdr, amt, abfd) != amt)
            return FALSE;
          memcpy (nlm_version_header (abfd)->stamp, thdr.stamp,
                  sizeof (thdr.stamp));
            return FALSE;
          memcpy (nlm_version_header (abfd)->stamp, thdr.stamp,
                  sizeof (thdr.stamp));
@@ -424,7 +202,7 @@ nlm_swap_auxiliary_headers_in (abfd)
          Nlm_External_Extended_Header thdr;
 
          amt = sizeof (thdr);
          Nlm_External_Extended_Header thdr;
 
          amt = sizeof (thdr);
-         if (bfd_bread ((PTR) &thdr, amt, abfd) != amt)
+         if (bfd_bread ((void *) &thdr, amt, abfd) != amt)
            return FALSE;
          memcpy (nlm_extended_header (abfd)->stamp, thdr.stamp,
                  sizeof (thdr.stamp));
            return FALSE;
          memcpy (nlm_extended_header (abfd)->stamp, thdr.stamp,
                  sizeof (thdr.stamp));
@@ -490,16 +268,16 @@ nlm_swap_auxiliary_headers_in (abfd)
       else if (strncmp (tempstr, "CoPyRiGhT=", 10) == 0)
        {
          amt = sizeof (nlm_copyright_header (abfd)->stamp);
       else if (strncmp (tempstr, "CoPyRiGhT=", 10) == 0)
        {
          amt = sizeof (nlm_copyright_header (abfd)->stamp);
-         if (bfd_bread ((PTR) nlm_copyright_header (abfd)->stamp,
+         if (bfd_bread ((void *) nlm_copyright_header (abfd)->stamp,
                        amt, abfd) != amt)
            return FALSE;
                        amt, abfd) != amt)
            return FALSE;
-         if (bfd_bread ((PTR) &(nlm_copyright_header (abfd)
+         if (bfd_bread ((void *) &(nlm_copyright_header (abfd)
                                ->copyrightMessageLength),
                        (bfd_size_type) 1, abfd) != 1)
            return FALSE;
          /* The copyright message is a variable length string.  */
          amt = nlm_copyright_header (abfd)->copyrightMessageLength + 1;
                                ->copyrightMessageLength),
                        (bfd_size_type) 1, abfd) != 1)
            return FALSE;
          /* The copyright message is a variable length string.  */
          amt = nlm_copyright_header (abfd)->copyrightMessageLength + 1;
-         if (bfd_bread ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
+         if (bfd_bread ((void *) nlm_copyright_header (abfd)->copyrightMessage,
                        amt, abfd) != amt)
            return FALSE;
        }
                        amt, abfd) != amt)
            return FALSE;
        }
@@ -510,15 +288,15 @@ nlm_swap_auxiliary_headers_in (abfd)
          file_ptr dataOffset;
          bfd_size_type dataLength;
          char dataStamp[8];
          file_ptr dataOffset;
          bfd_size_type dataLength;
          char dataStamp[8];
-         PTR hdr;
+         void * hdr;
 
          /* Read the stamp ("CuStHeAd").  */
          amt = sizeof (thdr.stamp);
 
          /* Read the stamp ("CuStHeAd").  */
          amt = sizeof (thdr.stamp);
-         if (bfd_bread ((PTR) thdr.stamp, amt, abfd) != amt)
+         if (bfd_bread ((void *) thdr.stamp, amt, abfd) != amt)
            return FALSE;
          /* Read the length of this custom header.  */
          amt = sizeof (thdr.length);
            return FALSE;
          /* Read the length of this custom header.  */
          amt = sizeof (thdr.length);
-         if (bfd_bread ((PTR) thdr.length, amt, abfd) != amt)
+         if (bfd_bread ((void *) thdr.length, amt, abfd) != amt)
            return FALSE;
          hdrLength = get_word (abfd, (bfd_byte *) thdr.length);
          /* Read further fields if we have them.  */
            return FALSE;
          hdrLength = get_word (abfd, (bfd_byte *) thdr.length);
          /* Read further fields if we have them.  */
@@ -527,7 +305,7 @@ nlm_swap_auxiliary_headers_in (abfd)
          else
            {
              amt = sizeof (thdr.dataOffset);
          else
            {
              amt = sizeof (thdr.dataOffset);
-             if (bfd_bread ((PTR) thdr.dataOffset, amt, abfd) != amt)
+             if (bfd_bread ((void *) thdr.dataOffset, amt, abfd) != amt)
                return FALSE;
              dataOffset = get_word (abfd, (bfd_byte *) thdr.dataOffset);
            }
                return FALSE;
              dataOffset = get_word (abfd, (bfd_byte *) thdr.dataOffset);
            }
@@ -536,7 +314,7 @@ nlm_swap_auxiliary_headers_in (abfd)
          else
            {
              amt = sizeof (thdr.dataLength);
          else
            {
              amt = sizeof (thdr.dataLength);
-             if (bfd_bread ((PTR) thdr.dataLength, amt, abfd) != amt)
+             if (bfd_bread ((void *) thdr.dataLength, amt, abfd) != amt)
                return FALSE;
              dataLength = get_word (abfd, (bfd_byte *) thdr.dataLength);
            }
                return FALSE;
              dataLength = get_word (abfd, (bfd_byte *) thdr.dataLength);
            }
@@ -545,7 +323,7 @@ nlm_swap_auxiliary_headers_in (abfd)
          else
            {
              amt = sizeof (dataStamp);
          else
            {
              amt = sizeof (dataStamp);
-             if (bfd_bread ((PTR) dataStamp, amt, abfd) != amt)
+             if (bfd_bread ((void *) dataStamp, amt, abfd) != amt)
                return FALSE;
            }
 
                return FALSE;
            }
 
@@ -579,7 +357,7 @@ nlm_swap_auxiliary_headers_in (abfd)
              pos = bfd_tell (abfd);
              if (bfd_seek (abfd, dataOffset, SEEK_SET) != 0)
                return FALSE;
              pos = bfd_tell (abfd);
              if (bfd_seek (abfd, dataOffset, SEEK_SET) != 0)
                return FALSE;
-             contents = (bfd_byte *) bfd_alloc (abfd, dataLength);
+             contents = bfd_alloc (abfd, dataLength);
              if (contents == NULL)
                return FALSE;
              if (bfd_bread (contents, dataLength, abfd) != dataLength)
              if (contents == NULL)
                return FALSE;
              if (bfd_bread (contents, dataLength, abfd) != dataLength)
@@ -615,8 +393,7 @@ nlm_swap_auxiliary_headers_in (abfd)
                     null terminated section name
                     zeroes to adjust to 4 byte boundary
                     4 byte section data file pointer
                     null terminated section name
                     zeroes to adjust to 4 byte boundary
                     4 byte section data file pointer
-                    4 byte section size
-                    */
+                    4 byte section size.  */
 
                  name = (char *) p;
                  l = strlen (name) + 1;
 
                  name = (char *) p;
                  l = strlen (name) + 1;
@@ -628,7 +405,7 @@ nlm_swap_auxiliary_headers_in (abfd)
                  p += 4;
 
                  newsec = bfd_make_section_anyway (abfd, name);
                  p += 4;
 
                  newsec = bfd_make_section_anyway (abfd, name);
-                 if (newsec == (asection *) NULL)
+                 if (newsec == NULL)
                    return FALSE;
                  newsec->size = size;
                  if (filepos != 0)
                    return FALSE;
                  newsec->size = size;
                  if (filepos != 0)
@@ -656,12 +433,195 @@ nlm_swap_auxiliary_headers_in (abfd)
   return TRUE;
 }
 
   return TRUE;
 }
 
+const bfd_target *
+nlm_object_p (bfd *abfd)
+{
+  struct nlm_obj_tdata *preserved_tdata = nlm_tdata (abfd);
+  bfd_boolean (*backend_object_p) (bfd *);
+  void * x_fxdhdr = NULL;
+  Nlm_Internal_Fixed_Header *i_fxdhdrp;
+  struct nlm_obj_tdata *new_tdata = NULL;
+  const char *signature;
+  enum bfd_architecture arch;
+  bfd_size_type amt;
+
+  /* Some NLM formats have a prefix before the standard NLM fixed
+     header.  */
+  backend_object_p = nlm_backend_object_p_func (abfd);
+  if (backend_object_p)
+    {
+      if (!(*backend_object_p) (abfd))
+       goto got_wrong_format_error;
+    }
+
+  /* Read in the fixed length portion of the NLM header in external format.  */
+  amt = nlm_fixed_header_size (abfd);
+  x_fxdhdr = bfd_malloc (amt);
+  if (x_fxdhdr == NULL)
+    goto got_no_match;
+
+  if (bfd_bread ((void *) x_fxdhdr, amt, abfd) != amt)
+    {
+      if (bfd_get_error () != bfd_error_system_call)
+       goto got_wrong_format_error;
+      else
+       goto got_no_match;
+    }
+
+  /* Allocate an instance of the nlm_obj_tdata structure and hook it up to
+     the tdata pointer in the bfd.  */
+  amt = sizeof (struct nlm_obj_tdata);
+  new_tdata = bfd_zalloc (abfd, amt);
+  if (new_tdata == NULL)
+    goto got_no_match;
+
+  nlm_tdata (abfd) = new_tdata;
+
+  i_fxdhdrp = nlm_fixed_header (abfd);
+  nlm_swap_fixed_header_in (abfd, x_fxdhdr, i_fxdhdrp);
+  free (x_fxdhdr);
+  x_fxdhdr = NULL;
+
+  /* Check to see if we have an NLM file for this backend by matching
+     the NLM signature.  */
+  signature = nlm_signature (abfd);
+  if (signature != NULL
+      && *signature != '\0'
+      && strncmp ((char *) i_fxdhdrp->signature, signature,
+                 NLM_SIGNATURE_SIZE) != 0)
+    goto got_wrong_format_error;
+
+  /* There's no supported way to discover the endianess of an NLM, so test for
+     a sane version number after doing byte swapping appropriate for this
+     XVEC.  (Hack alert!)  */
+  if (i_fxdhdrp->version > 0xFFFF)
+    goto got_wrong_format_error;
+
+  /* There's no supported way to check for 32 bit versus 64 bit addresses,
+     so ignore this distinction for now.  (FIXME) */
+  /* Swap in the rest of the required header.  */
+  if (!nlm_swap_variable_header_in (abfd))
+    {
+      if (bfd_get_error () != bfd_error_system_call)
+       goto got_wrong_format_error;
+      else
+       goto got_no_match;
+    }
+
+  /* Add the sections supplied by all NLM's, and then read in the
+     auxiliary headers.  Reading the auxiliary headers may create
+     additional sections described in the cygnus_ext header.
+     From this point on we assume that we have an NLM, and do not
+     treat errors as indicating the wrong format.  */
+  if (!add_bfd_section (abfd, NLM_CODE_NAME,
+                       i_fxdhdrp->codeImageOffset,
+                       i_fxdhdrp->codeImageSize,
+                       (SEC_CODE | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
+                        | SEC_RELOC))
+      || !add_bfd_section (abfd, NLM_INITIALIZED_DATA_NAME,
+                          i_fxdhdrp->dataImageOffset,
+                          i_fxdhdrp->dataImageSize,
+                          (SEC_DATA | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
+                           | SEC_RELOC))
+      || !add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
+                          (file_ptr) 0,
+                          i_fxdhdrp->uninitializedDataSize,
+                          SEC_ALLOC))
+    goto got_no_match;
+
+  if (!nlm_swap_auxiliary_headers_in (abfd))
+    goto got_no_match;
+
+  if (nlm_fixed_header (abfd)->numberOfRelocationFixups != 0
+      || nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
+    abfd->flags |= HAS_RELOC;
+  if (nlm_fixed_header (abfd)->numberOfPublics != 0
+      || nlm_fixed_header (abfd)->numberOfDebugRecords != 0
+      || nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
+    abfd->flags |= HAS_SYMS;
+
+  arch = nlm_architecture (abfd);
+  if (arch != bfd_arch_unknown)
+    bfd_default_set_arch_mach (abfd, arch, (unsigned long) 0);
+
+  abfd->flags |= EXEC_P;
+  bfd_get_start_address (abfd) = nlm_fixed_header (abfd)->codeStartOffset;
+
+  return abfd->xvec;
+
+got_wrong_format_error:
+  bfd_set_error (bfd_error_wrong_format);
+got_no_match:
+  nlm_tdata (abfd) = preserved_tdata;
+  if (new_tdata != NULL)
+    bfd_release (abfd, new_tdata);
+  if (x_fxdhdr != NULL)
+    free (x_fxdhdr);
+
+  return NULL;
+}
+
+/* Swap and write out the variable length header.  All the fields must
+   exist in the NLM, and must exist in this order.  */
+
+static bfd_boolean
+nlm_swap_variable_header_out (bfd *abfd)
+{
+  bfd_byte temp[NLM_TARGET_LONG_SIZE];
+  bfd_size_type amt;
+
+  /* Write the description length and text members.  */
+  amt = sizeof (nlm_variable_header (abfd)->descriptionLength);
+  if (bfd_bwrite (& nlm_variable_header (abfd)->descriptionLength, amt,
+                 abfd) != amt)
+    return FALSE;
+  amt = nlm_variable_header (abfd)->descriptionLength + 1;
+  if (bfd_bwrite ((void *) nlm_variable_header (abfd)->descriptionText, amt,
+                 abfd) != amt)
+    return FALSE;
+
+  /* Convert and write the stackSize field.  */
+  put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->stackSize, temp);
+  amt = sizeof (temp);
+  if (bfd_bwrite (temp, amt, abfd) != amt)
+    return FALSE;
+
+  /* Convert and write the reserved field.  */
+  put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->reserved, temp);
+  amt = sizeof (temp);
+  if (bfd_bwrite (temp, amt, abfd) != amt)
+    return FALSE;
+
+  /* Write the oldThreadName field.  This field is a fixed length string.  */
+  amt = sizeof (nlm_variable_header (abfd)->oldThreadName);
+  if (bfd_bwrite (nlm_variable_header (abfd)->oldThreadName, amt,
+                 abfd) != amt)
+    return FALSE;
+
+  /* Write the screen name length and text members.  */
+  amt = sizeof (nlm_variable_header (abfd)->screenNameLength);
+  if (bfd_bwrite (& nlm_variable_header (abfd)->screenNameLength, amt,
+                abfd) != amt)
+    return FALSE;
+  amt = nlm_variable_header (abfd)->screenNameLength + 1;
+  if (bfd_bwrite (nlm_variable_header (abfd)->screenName, amt, abfd) != amt)
+    return FALSE;
+
+  /* Write the thread name length and text members.  */
+  amt = sizeof (nlm_variable_header (abfd)->threadNameLength);
+  if (bfd_bwrite (& nlm_variable_header (abfd)->threadNameLength, amt,
+                abfd) != amt)
+    return FALSE;
+  amt = nlm_variable_header (abfd)->threadNameLength + 1;
+  if (bfd_bwrite (nlm_variable_header (abfd)->threadName, amt, abfd) != amt)
+    return FALSE;
+  return TRUE;
+}
+
 /* Return whether there is a non-zero byte in a memory block.  */
 
 static bfd_boolean
 /* Return whether there is a non-zero byte in a memory block.  */
 
 static bfd_boolean
-find_nonzero (buf, size)
-     PTR buf;
-     size_t size;
+find_nonzero (void * buf, size_t size)
 {
   char *p = (char *) buf;
 
 {
   char *p = (char *) buf;
 
@@ -676,13 +636,12 @@ find_nonzero (buf, size)
    the caller to set up the stamp fields.  */
 
 static bfd_boolean
    the caller to set up the stamp fields.  */
 
 static bfd_boolean
-nlm_swap_auxiliary_headers_out (abfd)
-     bfd *abfd;
+nlm_swap_auxiliary_headers_out (bfd *abfd)
 {
   bfd_size_type amt;
 
   /* Write out the version header if there is one.  */
 {
   bfd_size_type amt;
 
   /* Write out the version header if there is one.  */
-  if (find_nonzero ((PTR) nlm_version_header (abfd),
+  if (find_nonzero (nlm_version_header (abfd),
                    sizeof (Nlm_Internal_Version_Header)))
     {
       Nlm_External_Version_Header thdr;
                    sizeof (Nlm_Internal_Version_Header)))
     {
       Nlm_External_Version_Header thdr;
@@ -700,7 +659,7 @@ nlm_swap_auxiliary_headers_out (abfd)
                (bfd_byte *) thdr.month);
       put_word (abfd, (bfd_vma) nlm_version_header (abfd)->day,
                (bfd_byte *) thdr.day);
                (bfd_byte *) thdr.month);
       put_word (abfd, (bfd_vma) nlm_version_header (abfd)->day,
                (bfd_byte *) thdr.day);
-      if (bfd_bwrite ((PTR) &thdr, (bfd_size_type) sizeof (thdr), abfd)
+      if (bfd_bwrite ((void *) &thdr, (bfd_size_type) sizeof (thdr), abfd)
          != sizeof (thdr))
        return FALSE;
     }
          != sizeof (thdr))
        return FALSE;
     }
@@ -709,29 +668,29 @@ nlm_swap_auxiliary_headers_out (abfd)
      tag in order to make the NW4.x and NW5.x loaders happy.  */
 
   /* Write out the copyright header if there is one.  */
      tag in order to make the NW4.x and NW5.x loaders happy.  */
 
   /* Write out the copyright header if there is one.  */
-  if (find_nonzero ((PTR) nlm_copyright_header (abfd),
+  if (find_nonzero (nlm_copyright_header (abfd),
                    sizeof (Nlm_Internal_Copyright_Header)))
     {
       Nlm_External_Copyright_Header thdr;
 
       memcpy (thdr.stamp, "CoPyRiGhT=", 10);
       amt = sizeof (thdr.stamp);
                    sizeof (Nlm_Internal_Copyright_Header)))
     {
       Nlm_External_Copyright_Header thdr;
 
       memcpy (thdr.stamp, "CoPyRiGhT=", 10);
       amt = sizeof (thdr.stamp);
-      if (bfd_bwrite ((PTR) thdr.stamp, amt, abfd) != amt)
+      if (bfd_bwrite ((void *) thdr.stamp, amt, abfd) != amt)
        return FALSE;
       thdr.copyrightMessageLength[0] =
        nlm_copyright_header (abfd)->copyrightMessageLength;
       amt = 1;
        return FALSE;
       thdr.copyrightMessageLength[0] =
        nlm_copyright_header (abfd)->copyrightMessageLength;
       amt = 1;
-      if (bfd_bwrite ((PTR) thdr.copyrightMessageLength, amt, abfd) != amt)
+      if (bfd_bwrite ((void *) thdr.copyrightMessageLength, amt, abfd) != amt)
        return FALSE;
       /* The copyright message is a variable length string.  */
       amt = nlm_copyright_header (abfd)->copyrightMessageLength + 1;
        return FALSE;
       /* The copyright message is a variable length string.  */
       amt = nlm_copyright_header (abfd)->copyrightMessageLength + 1;
-      if (bfd_bwrite ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
+      if (bfd_bwrite ((void *) nlm_copyright_header (abfd)->copyrightMessage,
                     amt, abfd) != amt)
        return FALSE;
     }
 
   /* Write out the extended header if there is one.  */
                     amt, abfd) != amt)
        return FALSE;
     }
 
   /* Write out the extended header if there is one.  */
-  if (find_nonzero ((PTR) nlm_extended_header (abfd),
+  if (find_nonzero (nlm_extended_header (abfd),
                    sizeof (Nlm_Internal_Extended_Header)))
     {
       Nlm_External_Extended_Header thdr;
                    sizeof (Nlm_Internal_Extended_Header)))
     {
       Nlm_External_Extended_Header thdr;
@@ -824,20 +783,20 @@ nlm_swap_auxiliary_headers_out (abfd)
       put_word (abfd,
                (bfd_vma) nlm_extended_header (abfd)->reserved5,
                (bfd_byte *) thdr.reserved5);
       put_word (abfd,
                (bfd_vma) nlm_extended_header (abfd)->reserved5,
                (bfd_byte *) thdr.reserved5);
-      if (bfd_bwrite ((PTR) &thdr, (bfd_size_type) sizeof (thdr), abfd)
+      if (bfd_bwrite ((void *) &thdr, (bfd_size_type) sizeof (thdr), abfd)
          != sizeof (thdr))
        return FALSE;
     }
 
   /* Write out the custom header if there is one.   */
          != sizeof (thdr))
        return FALSE;
     }
 
   /* Write out the custom header if there is one.   */
-  if (find_nonzero ((PTR) nlm_custom_header (abfd),
+  if (find_nonzero (nlm_custom_header (abfd),
                    sizeof (Nlm_Internal_Custom_Header)))
     {
       Nlm_External_Custom_Header thdr;
       bfd_boolean ds;
       bfd_size_type hdrLength;
 
                    sizeof (Nlm_Internal_Custom_Header)))
     {
       Nlm_External_Custom_Header thdr;
       bfd_boolean ds;
       bfd_size_type hdrLength;
 
-      ds = find_nonzero ((PTR) nlm_custom_header (abfd)->dataStamp,
+      ds = find_nonzero (nlm_custom_header (abfd)->dataStamp,
                         sizeof (nlm_custom_header (abfd)->dataStamp));
       memcpy (thdr.stamp, "CuStHeAd", 8);
       hdrLength = (2 * NLM_TARGET_LONG_SIZE + (ds ? 8 : 0)
                         sizeof (nlm_custom_header (abfd)->dataStamp));
       memcpy (thdr.stamp, "CuStHeAd", 8);
       hdrLength = (2 * NLM_TARGET_LONG_SIZE + (ds ? 8 : 0)
@@ -851,7 +810,7 @@ nlm_swap_auxiliary_headers_out (abfd)
        {
          BFD_ASSERT (nlm_custom_header (abfd)->hdrLength == 0);
          amt = sizeof (thdr) - sizeof (thdr.dataStamp);
        {
          BFD_ASSERT (nlm_custom_header (abfd)->hdrLength == 0);
          amt = sizeof (thdr) - sizeof (thdr.dataStamp);
-         if (bfd_bwrite ((PTR) &thdr, amt, abfd) != amt)
+         if (bfd_bwrite ((void *) &thdr, amt, abfd) != amt)
            return FALSE;
        }
       else
            return FALSE;
        }
       else
@@ -859,7 +818,7 @@ nlm_swap_auxiliary_headers_out (abfd)
          memcpy (thdr.dataStamp, nlm_custom_header (abfd)->dataStamp,
                  sizeof (thdr.dataStamp));
          amt = sizeof (thdr);
          memcpy (thdr.dataStamp, nlm_custom_header (abfd)->dataStamp,
                  sizeof (thdr.dataStamp));
          amt = sizeof (thdr);
-         if (bfd_bwrite ((PTR) &thdr, amt, abfd) != amt)
+         if (bfd_bwrite ((void *) &thdr, amt, abfd) != amt)
            return FALSE;
          amt = nlm_custom_header (abfd)->hdrLength;
          if (bfd_bwrite (nlm_custom_header (abfd)->hdr, amt, abfd) != amt)
            return FALSE;
          amt = nlm_custom_header (abfd)->hdrLength;
          if (bfd_bwrite (nlm_custom_header (abfd)->hdr, amt, abfd) != amt)
@@ -868,7 +827,7 @@ nlm_swap_auxiliary_headers_out (abfd)
     }
 
   /* Write out the Cygnus debugging header if there is one.  */
     }
 
   /* Write out the Cygnus debugging header if there is one.  */
-  if (find_nonzero ((PTR) nlm_cygnus_ext_header (abfd),
+  if (find_nonzero (nlm_cygnus_ext_header (abfd),
                    sizeof (Nlm_Internal_Cygnus_Ext_Header)))
     {
       Nlm_External_Custom_Header thdr;
                    sizeof (Nlm_Internal_Cygnus_Ext_Header)))
     {
       Nlm_External_Custom_Header thdr;
@@ -882,7 +841,7 @@ nlm_swap_auxiliary_headers_out (abfd)
                (bfd_byte *) thdr.dataLength);
       memcpy (thdr.dataStamp, "CyGnUsEx", 8);
       amt = sizeof (thdr);
                (bfd_byte *) thdr.dataLength);
       memcpy (thdr.dataStamp, "CyGnUsEx", 8);
       amt = sizeof (thdr);
-      if (bfd_bwrite ((PTR) &thdr, amt, abfd) != amt)
+      if (bfd_bwrite ((void *) &thdr, amt, abfd) != amt)
        return FALSE;
     }
 
        return FALSE;
     }
 
@@ -899,8 +858,7 @@ nlm_swap_auxiliary_headers_out (abfd)
    on this size.  */
 
 long
    on this size.  */
 
 long
-nlm_get_symtab_upper_bound (abfd)
-     bfd *abfd;
+nlm_get_symtab_upper_bound (bfd *abfd)
 {
   Nlm_Internal_Fixed_Header *i_fxdhdrp;        /* Nlm file header, internal form.  */
   long symcount;
 {
   Nlm_Internal_Fixed_Header *i_fxdhdrp;        /* Nlm file header, internal form.  */
   long symcount;
@@ -911,83 +869,7 @@ nlm_get_symtab_upper_bound (abfd)
              + i_fxdhdrp->numberOfDebugRecords
              + i_fxdhdrp->numberOfExternalReferences);
   symtab_size = (symcount + 1) * (sizeof (asymbol));
              + i_fxdhdrp->numberOfDebugRecords
              + i_fxdhdrp->numberOfExternalReferences);
   symtab_size = (symcount + 1) * (sizeof (asymbol));
-  return (symtab_size);
-}
-
-/* Note that bfd_get_symcount is guaranteed to be zero if slurping the
-   symbol table fails.  */
-
-long
-nlm_canonicalize_symtab (abfd, alocation)
-     bfd *abfd;
-     asymbol **alocation;
-{
-  nlm_symbol_type *symbase;
-  bfd_size_type counter = 0;
-
-  if (! nlm_slurp_symbol_table (abfd))
-    return -1;
-  symbase = nlm_get_symbols (abfd);
-  while (counter < bfd_get_symcount (abfd))
-    {
-      *alocation++ = &symbase->symbol;
-      symbase++;
-      counter++;
-    }
-  *alocation = (asymbol *) NULL;
-  return bfd_get_symcount (abfd);
-}
-
-/* Make an NLM symbol.  There is nothing special to do here.  */
-
-asymbol *
-nlm_make_empty_symbol (abfd)
-     bfd *abfd;
-{
-  bfd_size_type amt = sizeof (nlm_symbol_type);
-  nlm_symbol_type *new = (nlm_symbol_type *) bfd_zalloc (abfd, amt);
-
-  if (new)
-    new->symbol.the_bfd = abfd;
-  return &new->symbol;
-}
-
-/* Get symbol information.  */
-
-void
-nlm_get_symbol_info (ignore_abfd, symbol, ret)
-     bfd *ignore_abfd ATTRIBUTE_UNUSED;
-     asymbol *symbol;
-     symbol_info *ret;
-{
-  bfd_symbol_info (symbol, ret);
-}
-
-/* Print symbol information.  */
-
-void
-nlm_print_symbol (abfd, afile, symbol, how)
-     bfd *abfd;
-     PTR afile;
-     asymbol *symbol;
-     bfd_print_symbol_type how;
-{
-  FILE *file = (FILE *) afile;
-
-  switch (how)
-    {
-    case bfd_print_symbol_name:
-    case bfd_print_symbol_more:
-      if (symbol->name)
-       fprintf (file, "%s", symbol->name);
-      break;
-    case bfd_print_symbol_all:
-      bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
-      fprintf (file, " %-5s", symbol->section->name);
-      if (symbol->name)
-       fprintf (file, " %s", symbol->name);
-      break;
-    }
+  return symtab_size;
 }
 
 /* Slurp in nlm symbol table.
 }
 
 /* Slurp in nlm symbol table.
@@ -1004,14 +886,13 @@ nlm_print_symbol (abfd, afile, symbol, how)
    records we also read in the associated reloc information, which is
    attached to the symbol.
 
    records we also read in the associated reloc information, which is
    attached to the symbol.
 
-   The bfd symbols are copied to SYMPTRS.
+   The bfd symbols are copied to SYMvoid *S.
 
    When we return, the bfd symcount is either zero or contains the correct
    number of symbols.  */
 
 static bfd_boolean
 
    When we return, the bfd symcount is either zero or contains the correct
    number of symbols.  */
 
 static bfd_boolean
-nlm_slurp_symbol_table (abfd)
-     bfd *abfd;
+nlm_slurp_symbol_table (bfd *abfd)
 {
   Nlm_Internal_Fixed_Header *i_fxdhdrp;        /* Nlm file header, internal form.  */
   bfd_size_type totsymcount;   /* Number of NLM symbols.  */
 {
   Nlm_Internal_Fixed_Header *i_fxdhdrp;        /* Nlm file header, internal form.  */
   bfd_size_type totsymcount;   /* Number of NLM symbols.  */
@@ -1020,8 +901,8 @@ nlm_slurp_symbol_table (abfd)
   unsigned char symlength;     /* Symbol length read into here.  */
   unsigned char symtype;       /* Type of debugging symbol.  */
   bfd_byte temp[NLM_TARGET_LONG_SIZE]; /* Symbol offsets read into here.  */
   unsigned char symlength;     /* Symbol length read into here.  */
   unsigned char symtype;       /* Type of debugging symbol.  */
   bfd_byte temp[NLM_TARGET_LONG_SIZE]; /* Symbol offsets read into here.  */
-  bfd_boolean (*read_import_func) PARAMS ((bfd *, nlm_symbol_type *));
-  bfd_boolean (*set_public_section_func) PARAMS ((bfd *, nlm_symbol_type *));
+  bfd_boolean (*read_import_func) (bfd *, nlm_symbol_type *);
+  bfd_boolean (*set_public_section_func) (bfd *, nlm_symbol_type *);
   bfd_size_type amt;
 
   if (nlm_get_symbols (abfd) != NULL)
   bfd_size_type amt;
 
   if (nlm_get_symbols (abfd) != NULL)
@@ -1047,7 +928,7 @@ nlm_slurp_symbol_table (abfd)
     return FALSE;
 
   amt = totsymcount * sizeof (nlm_symbol_type);
     return FALSE;
 
   amt = totsymcount * sizeof (nlm_symbol_type);
-  sym = ((nlm_symbol_type *) bfd_zalloc (abfd, amt));
+  sym = bfd_zalloc (abfd, amt);
   if (!sym)
     return FALSE;
   nlm_set_symbols (abfd, sym);
   if (!sym)
     return FALSE;
   nlm_set_symbols (abfd, sym);
@@ -1061,19 +942,19 @@ nlm_slurp_symbol_table (abfd)
   while (abfd->symcount < symcount)
     {
       amt = sizeof (symlength);
   while (abfd->symcount < symcount)
     {
       amt = sizeof (symlength);
-      if (bfd_bread ((PTR) &symlength, amt, abfd) != amt)
+      if (bfd_bread ((void *) &symlength, amt, abfd) != amt)
        return FALSE;
       amt = symlength;
       sym->symbol.the_bfd = abfd;
       sym->symbol.name = bfd_alloc (abfd, amt + 1);
       if (!sym->symbol.name)
        return FALSE;
        return FALSE;
       amt = symlength;
       sym->symbol.the_bfd = abfd;
       sym->symbol.name = bfd_alloc (abfd, amt + 1);
       if (!sym->symbol.name)
        return FALSE;
-      if (bfd_bread ((PTR) sym->symbol.name, amt, abfd) != amt)
+      if (bfd_bread ((void *) sym->symbol.name, amt, abfd) != amt)
        return FALSE;
       /* Cast away const.  */
       ((char *) (sym->symbol.name))[symlength] = '\0';
       amt = sizeof (temp);
        return FALSE;
       /* Cast away const.  */
       ((char *) (sym->symbol.name))[symlength] = '\0';
       amt = sizeof (temp);
-      if (bfd_bread ((PTR) temp, amt, abfd) != amt)
+      if (bfd_bread ((void *) temp, amt, abfd) != amt)
        return FALSE;
       sym->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
       sym->symbol.value = get_word (abfd, temp);
        return FALSE;
       sym->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
       sym->symbol.value = get_word (abfd, temp);
@@ -1094,10 +975,8 @@ nlm_slurp_symbol_table (abfd)
                bfd_get_section_by_name (abfd, NLM_CODE_NAME);
            }
          else
                bfd_get_section_by_name (abfd, NLM_CODE_NAME);
            }
          else
-           {
-             sym->symbol.section =
-               bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
-           }
+           sym->symbol.section =
+             bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
        }
       sym->rcnt = 0;
       abfd->symcount++;
        }
       sym->rcnt = 0;
       abfd->symcount++;
@@ -1115,30 +994,29 @@ nlm_slurp_symbol_table (abfd)
       while (abfd->symcount < symcount)
        {
          amt = sizeof (symtype);
       while (abfd->symcount < symcount)
        {
          amt = sizeof (symtype);
-         if (bfd_bread ((PTR) &symtype, amt, abfd) != amt)
+         if (bfd_bread ((void *) &symtype, amt, abfd) != amt)
            return FALSE;
          amt = sizeof (temp);
            return FALSE;
          amt = sizeof (temp);
-         if (bfd_bread ((PTR) temp, amt, abfd) != amt)
+         if (bfd_bread ((void *) temp, amt, abfd) != amt)
            return FALSE;
          amt = sizeof (symlength);
            return FALSE;
          amt = sizeof (symlength);
-         if (bfd_bread ((PTR) &symlength, amt, abfd) != amt)
+         if (bfd_bread ((void *) &symlength, amt, abfd) != amt)
            return FALSE;
          amt = symlength;
          sym->symbol.the_bfd = abfd;
          sym->symbol.name = bfd_alloc (abfd, amt + 1);
          if (!sym->symbol.name)
            return FALSE;
            return FALSE;
          amt = symlength;
          sym->symbol.the_bfd = abfd;
          sym->symbol.name = bfd_alloc (abfd, amt + 1);
          if (!sym->symbol.name)
            return FALSE;
-         if (bfd_bread ((PTR) sym->symbol.name, amt, abfd) != amt)
+         if (bfd_bread ((void *) sym->symbol.name, amt, abfd) != amt)
            return FALSE;
          /* Cast away const.  */
          ((char *) (sym->symbol.name))[symlength] = '\0';
          sym->symbol.flags = BSF_LOCAL;
          sym->symbol.value = get_word (abfd, temp);
            return FALSE;
          /* Cast away const.  */
          ((char *) (sym->symbol.name))[symlength] = '\0';
          sym->symbol.flags = BSF_LOCAL;
          sym->symbol.value = get_word (abfd, temp);
+
          if (symtype == 0)
          if (symtype == 0)
-           {
-             sym->symbol.section =
-               bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
-           }
+           sym->symbol.section =
+             bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
          else if (symtype == 1)
            {
              sym->symbol.flags |= BSF_FUNCTION;
          else if (symtype == 1)
            {
              sym->symbol.flags |= BSF_FUNCTION;
@@ -1146,9 +1024,8 @@ nlm_slurp_symbol_table (abfd)
                bfd_get_section_by_name (abfd, NLM_CODE_NAME);
            }
          else
                bfd_get_section_by_name (abfd, NLM_CODE_NAME);
            }
          else
-           {
-             sym->symbol.section = bfd_abs_section_ptr;
-           }
+           sym->symbol.section = bfd_abs_section_ptr;
+
          sym->rcnt = 0;
          abfd->symcount++;
          sym++;
          sym->rcnt = 0;
          abfd->symcount++;
          sym++;
@@ -1175,6 +1052,78 @@ nlm_slurp_symbol_table (abfd)
 
   return TRUE;
 }
 
   return TRUE;
 }
+
+/* Note that bfd_get_symcount is guaranteed to be zero if slurping the
+   symbol table fails.  */
+
+long
+nlm_canonicalize_symtab (bfd *abfd, asymbol **alocation)
+{
+  nlm_symbol_type *symbase;
+  bfd_size_type counter = 0;
+
+  if (! nlm_slurp_symbol_table (abfd))
+    return -1;
+  symbase = nlm_get_symbols (abfd);
+  while (counter < bfd_get_symcount (abfd))
+    {
+      *alocation++ = &symbase->symbol;
+      symbase++;
+      counter++;
+    }
+  *alocation = NULL;
+  return bfd_get_symcount (abfd);
+}
+
+/* Make an NLM symbol.  There is nothing special to do here.  */
+
+asymbol *
+nlm_make_empty_symbol (bfd *abfd)
+{
+  bfd_size_type amt = sizeof (nlm_symbol_type);
+  nlm_symbol_type *new = bfd_zalloc (abfd, amt);
+
+  if (new == NULL)
+    return NULL;
+  new->symbol.the_bfd = abfd;
+  return & new->symbol;
+}
+
+/* Get symbol information.  */
+
+void
+nlm_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
+                    asymbol *symbol,
+                    symbol_info *ret)
+{
+  bfd_symbol_info (symbol, ret);
+}
+
+/* Print symbol information.  */
+
+void
+nlm_print_symbol (bfd *abfd,
+                 void * afile,
+                 asymbol *symbol,
+                 bfd_print_symbol_type how)
+{
+  FILE *file = (FILE *) afile;
+
+  switch (how)
+    {
+    case bfd_print_symbol_name:
+    case bfd_print_symbol_more:
+      if (symbol->name)
+       fprintf (file, "%s", symbol->name);
+      break;
+    case bfd_print_symbol_all:
+      bfd_print_symbol_vandf (abfd, (void *) file, symbol);
+      fprintf (file, " %-5s", symbol->section->name);
+      if (symbol->name)
+       fprintf (file, " %s", symbol->name);
+      break;
+    }
+}
 \f
 /* Get the relocs for an NLM file.  There are two types of relocs.
    Imports are relocs against symbols defined in other NLM files.  We
 \f
 /* Get the relocs for an NLM file.  There are two types of relocs.
    Imports are relocs against symbols defined in other NLM files.  We
@@ -1190,11 +1139,9 @@ nlm_slurp_symbol_table (abfd)
    section.  */
 
 static bfd_boolean
    section.  */
 
 static bfd_boolean
-nlm_slurp_reloc_fixups (abfd)
-     bfd *abfd;
+nlm_slurp_reloc_fixups (bfd *abfd)
 {
 {
-  bfd_boolean (*read_func)
-    PARAMS ((bfd *, nlm_symbol_type *, asection **, arelent *));
+  bfd_boolean (*read_func) (bfd *, nlm_symbol_type *, asection **, arelent *);
   bfd_size_type count, amt;
   arelent *rels;
   asection **secs;
   bfd_size_type count, amt;
   arelent *rels;
   asection **secs;
@@ -1211,9 +1158,9 @@ nlm_slurp_reloc_fixups (abfd)
 
   count = nlm_fixed_header (abfd)->numberOfRelocationFixups;
   amt = count * sizeof (arelent);
 
   count = nlm_fixed_header (abfd)->numberOfRelocationFixups;
   amt = count * sizeof (arelent);
-  rels = (arelent *) bfd_alloc (abfd, amt);
+  rels = bfd_alloc (abfd, amt);
   amt = count * sizeof (asection *);
   amt = count * sizeof (asection *);
-  secs = (asection **) bfd_alloc (abfd, amt);
+  secs = bfd_alloc (abfd, amt);
   if ((rels == NULL || secs == NULL) && count != 0)
     return FALSE;
   nlm_relocation_fixups (abfd) = rels;
   if ((rels == NULL || secs == NULL) && count != 0)
     return FALSE;
   nlm_relocation_fixups (abfd) = rels;
@@ -1223,7 +1170,7 @@ nlm_slurp_reloc_fixups (abfd)
      the machine specific reloc information is.  */
   while (count-- != 0)
     {
      the machine specific reloc information is.  */
   while (count-- != 0)
     {
-      if (! (*read_func) (abfd, (nlm_symbol_type *) NULL, secs, rels))
+      if (! (*read_func) (abfd, NULL, secs, rels))
        {
          nlm_relocation_fixups (abfd) = NULL;
          nlm_relocation_fixup_secs (abfd) = NULL;
        {
          nlm_relocation_fixups (abfd) = NULL;
          nlm_relocation_fixup_secs (abfd) = NULL;
@@ -1241,9 +1188,7 @@ nlm_slurp_reloc_fixups (abfd)
    That will be handled when they are actually read.  */
 
 long
    That will be handled when they are actually read.  */
 
 long
-nlm_get_reloc_upper_bound (abfd, sec)
-     bfd *abfd;
-     asection *sec;
+nlm_get_reloc_upper_bound (bfd *abfd, asection *sec)
 {
   nlm_symbol_type *syms;
   bfd_size_type count;
 {
   nlm_symbol_type *syms;
   bfd_size_type count;
@@ -1279,16 +1224,15 @@ nlm_get_reloc_upper_bound (abfd, sec)
 /* Get the relocs themselves.  */
 
 long
 /* Get the relocs themselves.  */
 
 long
-nlm_canonicalize_reloc (abfd, sec, relptr, symbols)
-     bfd *abfd;
-     asection *sec;
-     arelent **relptr;
-     asymbol **symbols;
+nlm_canonicalize_reloc (bfd *abfd,
+                       asection *sec,
+                       arelent **relptr,
+                       asymbol **symbols)
 {
   arelent *rels;
   asection **secs;
   bfd_size_type count, i;
 {
   arelent *rels;
   asection **secs;
   bfd_size_type count, i;
-  unsigned int ret;
+  long ret;
 
   /* Get the relocation fixups.  */
   rels = nlm_relocation_fixups (abfd);
 
   /* Get the relocation fixups.  */
   rels = nlm_relocation_fixups (abfd);
@@ -1359,8 +1303,7 @@ nlm_canonicalize_reloc (abfd, sec, relptr, symbols)
    final values.  */
 
 static bfd_boolean
    final values.  */
 
 static bfd_boolean
-nlm_compute_section_file_positions (abfd)
-     bfd *abfd;
+nlm_compute_section_file_positions (bfd *abfd)
 {
   file_ptr sofar;
   asection *sec;
 {
   file_ptr sofar;
   asection *sec;
@@ -1402,21 +1345,21 @@ nlm_compute_section_file_positions (abfd)
            + nlm_variable_header (abfd)->threadNameLength + 1);
 
   /* The auxiliary headers.  */
            + nlm_variable_header (abfd)->threadNameLength + 1);
 
   /* The auxiliary headers.  */
-  if (find_nonzero ((PTR) nlm_version_header (abfd),
+  if (find_nonzero (nlm_version_header (abfd),
                    sizeof (Nlm_Internal_Version_Header)))
     sofar += sizeof (Nlm_External_Version_Header);
                    sizeof (Nlm_Internal_Version_Header)))
     sofar += sizeof (Nlm_External_Version_Header);
-  if (find_nonzero ((PTR) nlm_extended_header (abfd),
+  if (find_nonzero (nlm_extended_header (abfd),
                    sizeof (Nlm_Internal_Extended_Header)))
     sofar += sizeof (Nlm_External_Extended_Header);
                    sizeof (Nlm_Internal_Extended_Header)))
     sofar += sizeof (Nlm_External_Extended_Header);
-  if (find_nonzero ((PTR) nlm_copyright_header (abfd),
+  if (find_nonzero (nlm_copyright_header (abfd),
                    sizeof (Nlm_Internal_Copyright_Header)))
     sofar += (sizeof (Nlm_External_Copyright_Header)
              + nlm_copyright_header (abfd)->copyrightMessageLength + 1);
                    sizeof (Nlm_Internal_Copyright_Header)))
     sofar += (sizeof (Nlm_External_Copyright_Header)
              + nlm_copyright_header (abfd)->copyrightMessageLength + 1);
-  if (find_nonzero ((PTR) nlm_custom_header (abfd),
+  if (find_nonzero (nlm_custom_header (abfd),
                    sizeof (Nlm_Internal_Custom_Header)))
     sofar += (sizeof (Nlm_External_Custom_Header)
              + nlm_custom_header (abfd)->hdrLength);
                    sizeof (Nlm_Internal_Custom_Header)))
     sofar += (sizeof (Nlm_External_Custom_Header)
              + nlm_custom_header (abfd)->hdrLength);
-  if (find_nonzero ((PTR) nlm_cygnus_ext_header (abfd),
+  if (find_nonzero (nlm_cygnus_ext_header (abfd),
                    sizeof (Nlm_Internal_Cygnus_Ext_Header)))
     sofar += sizeof (Nlm_External_Custom_Header);
 
                    sizeof (Nlm_Internal_Cygnus_Ext_Header)))
     sofar += sizeof (Nlm_External_Custom_Header);
 
@@ -1433,7 +1376,7 @@ nlm_compute_section_file_positions (abfd)
   data_align = 0;
   bss = 0;
   other_align = 0;
   data_align = 0;
   bss = 0;
   other_align = 0;
-  for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
+  for (sec = abfd->sections; sec != NULL; sec = sec->next)
     {
       flagword f;
 
     {
       flagword f;
 
@@ -1489,7 +1432,7 @@ nlm_compute_section_file_positions (abfd)
   nlm_fixed_header (abfd)->dataImageSize = data;
   nlm_fixed_header (abfd)->uninitializedDataSize = bss;
 
   nlm_fixed_header (abfd)->dataImageSize = data;
   nlm_fixed_header (abfd)->uninitializedDataSize = bss;
 
-  for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
+  for (sec = abfd->sections; sec != NULL; sec = sec->next)
     {
       flagword f;
 
     {
       flagword f;
 
@@ -1565,12 +1508,11 @@ nlm_compute_section_file_positions (abfd)
    variable size header information must be known.  */
 
 bfd_boolean
    variable size header information must be known.  */
 
 bfd_boolean
-nlm_set_section_contents (abfd, section, location, offset, count)
-     bfd *abfd;
-     asection *section;
-     const PTR location;
-     file_ptr offset;
-     bfd_size_type count;
+nlm_set_section_contents (bfd *abfd,
+                         asection *section,
+                         const void * location,
+                         file_ptr offset,
+                         bfd_size_type count)
 {
   if (! abfd->output_has_begun
       && ! nlm_compute_section_file_positions (abfd))
 {
   if (! abfd->output_has_begun
       && ! nlm_compute_section_file_positions (abfd))
@@ -1586,7 +1528,7 @@ nlm_set_section_contents (abfd, section, location, offset, count)
   if (section->reloc_count != 0)
     {
       bfd_boolean (*mangle_relocs_func)
   if (section->reloc_count != 0)
     {
       bfd_boolean (*mangle_relocs_func)
-       PARAMS ((bfd *, asection *, const PTR, bfd_vma, bfd_size_type));
+       (bfd *, asection *, const void *, bfd_vma, bfd_size_type);
 
       mangle_relocs_func = nlm_mangle_relocs_func (abfd);
       if (mangle_relocs_func != NULL)
 
       mangle_relocs_func = nlm_mangle_relocs_func (abfd);
       if (mangle_relocs_func != NULL)
@@ -1608,9 +1550,7 @@ nlm_set_section_contents (abfd, section, location, offset, count)
    write out the external relocs.  */
 
 static int
    write out the external relocs.  */
 
 static int
-nlm_external_reloc_compare (p1, p2)
-     const void *p1;
-     const void *p2;
+nlm_external_reloc_compare (const void *p1, const void *p2)
 {
   const struct reloc_and_sec *r1 = (const struct reloc_and_sec *) p1;
   const struct reloc_and_sec *r2 = (const struct reloc_and_sec *) p2;
 {
   const struct reloc_and_sec *r1 = (const struct reloc_and_sec *) p1;
   const struct reloc_and_sec *r2 = (const struct reloc_and_sec *) p2;
@@ -1656,22 +1596,20 @@ nlm_external_reloc_compare (p1, p2)
    list of outsymbols.  */
 
 bfd_boolean
    list of outsymbols.  */
 
 bfd_boolean
-nlm_write_object_contents (abfd)
-     bfd *abfd;
+nlm_write_object_contents (bfd *abfd)
 {
   asection *sec;
 {
   asection *sec;
-  bfd_boolean (*write_import_func) PARAMS ((bfd *, asection *, arelent *));
+  bfd_boolean (*write_import_func) (bfd *, asection *, arelent *);
   bfd_size_type external_reloc_count, internal_reloc_count, i, c;
   struct reloc_and_sec *external_relocs;
   asymbol **sym_ptr_ptr;
   file_ptr last;
   bfd_size_type external_reloc_count, internal_reloc_count, i, c;
   struct reloc_and_sec *external_relocs;
   asymbol **sym_ptr_ptr;
   file_ptr last;
-  bfd_boolean (*write_prefix_func) PARAMS ((bfd *));
+  bfd_boolean (*write_prefix_func) (bfd *);
   unsigned char *fixed_header = NULL;
   file_ptr pos;
   bfd_size_type amt;
 
   unsigned char *fixed_header = NULL;
   file_ptr pos;
   bfd_size_type amt;
 
-  fixed_header = ((unsigned char *)
-                 bfd_malloc (nlm_fixed_header_size (abfd)));
+  fixed_header = bfd_malloc (nlm_fixed_header_size (abfd));
   if (fixed_header == NULL)
     goto error_return;
 
   if (fixed_header == NULL)
     goto error_return;
 
@@ -1713,7 +1651,7 @@ nlm_write_object_contents (abfd)
      needed when they are written out below.  */
   internal_reloc_count = 0;
   external_reloc_count = 0;
      needed when they are written out below.  */
   internal_reloc_count = 0;
   external_reloc_count = 0;
-  for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
+  for (sec = abfd->sections; sec != NULL; sec = sec->next)
     {
       arelent **rel_ptr_ptr, **rel_end;
 
     {
       arelent **rel_ptr_ptr, **rel_end;
 
@@ -1759,11 +1697,11 @@ nlm_write_object_contents (abfd)
      symbol, so we must first gather together all the relocs against
      external symbols and sort them.  */
   amt = external_reloc_count * sizeof (struct reloc_and_sec);
      symbol, so we must first gather together all the relocs against
      external symbols and sort them.  */
   amt = external_reloc_count * sizeof (struct reloc_and_sec);
-  external_relocs = (struct reloc_and_sec *) bfd_alloc (abfd, amt);
-  if (external_relocs == (struct reloc_and_sec *) NULL)
+  external_relocs = bfd_alloc (abfd, amt);
+  if (external_relocs == NULL)
     goto error_return;
   i = 0;
     goto error_return;
   i = 0;
-  for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
+  for (sec = abfd->sections; sec != NULL; sec = sec->next)
     {
       arelent **rel_ptr_ptr, **rel_end;
 
     {
       arelent **rel_ptr_ptr, **rel_end;
 
@@ -1792,7 +1730,7 @@ nlm_write_object_contents (abfd)
   BFD_ASSERT (i == external_reloc_count);
 
   /* Sort the external relocs by name.  */
   BFD_ASSERT (i == external_reloc_count);
 
   /* Sort the external relocs by name.  */
-  qsort ((PTR) external_relocs, (size_t) external_reloc_count,
+  qsort (external_relocs, (size_t) external_reloc_count,
         sizeof (struct reloc_and_sec), nlm_external_reloc_compare);
 
   /* Write out the external relocs.  */
         sizeof (struct reloc_and_sec), nlm_external_reloc_compare);
 
   /* Write out the external relocs.  */
@@ -1828,10 +1766,10 @@ nlm_write_object_contents (abfd)
 
   /* Write out the public symbols (exports).  */
   sym_ptr_ptr = bfd_get_outsymbols (abfd);
 
   /* Write out the public symbols (exports).  */
   sym_ptr_ptr = bfd_get_outsymbols (abfd);
-  if (sym_ptr_ptr != (asymbol **) NULL)
+  if (sym_ptr_ptr != NULL)
     {
     {
-      bfd_vma (*get_public_offset_func) PARAMS ((bfd *, asymbol *));
-      bfd_boolean (*write_export_func) PARAMS ((bfd *, asymbol *, bfd_vma));
+      bfd_vma (*get_public_offset_func) (bfd *, asymbol *);
+      bfd_boolean (*write_export_func) (bfd *, asymbol *, bfd_vma);
 
       asymbol **sym_end;
 
 
       asymbol **sym_end;
 
This page took 0.041287 seconds and 4 git commands to generate.