Convert to C90 and a few tweaks.

1 files changed, 163 insertions, 241 deletions

diff --git a/bfd/archive.c b/bfd/archive.c
index ffb0bd4c875..c4171e7bc83 100644
--- a/bfd/archive.c
+++ b/bfd/archive.c
@@ -1,6 +1,6 @@
 /* BFD back-end for archive files (libraries).
    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-   2000, 2001, 2002
+   2000, 2001, 2002, 2003
    Free Software Foundation, Inc.
    Written by Cygnus Support.  Mostly Gumby Henkel-Wallace's fault.
 
@@ -158,28 +158,15 @@ struct ar_cache {
 #define ar_maxnamelen(abfd) ((abfd)->xvec->ar_max_namelen)
 
 #define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data))
-#define arch_hdr(bfd) ((struct ar_hdr *)arch_eltdata(bfd)->arch_header)
-
-static char *get_extended_arelt_filename
-  PARAMS ((bfd *arch, const char *name));
-static bfd_boolean do_slurp_bsd_armap
-  PARAMS ((bfd *abfd));
-static bfd_boolean do_slurp_coff_armap
-  PARAMS ((bfd *abfd));
-bfd_boolean bfd_elf64_archive_slurp_armap
-  PARAMS ((bfd *abfd));
-static const char *normalize
-  PARAMS ((bfd *, const char *file));
-static struct areltdata *bfd_ar_hdr_from_filesystem
-  PARAMS ((bfd *abfd, const char *, bfd *member));
+#define arch_hdr(bfd) ((struct ar_hdr *) arch_eltdata(bfd)->arch_header)
+
 
 bfd_boolean
-_bfd_generic_mkarchive (abfd)
-     bfd *abfd;
+_bfd_generic_mkarchive (bfd *abfd)
 {
   bfd_size_type amt = sizeof (struct artdata);
 
-  abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc (abfd, amt);
+  abfd->tdata.aout_ar_data = bfd_zalloc (abfd, amt);
   if (bfd_ardata (abfd) == NULL)
     return FALSE;
 
@@ -197,7 +184,8 @@ FUNCTION
 	bfd_get_next_mapent
 
 SYNOPSIS
-	symindex bfd_get_next_mapent(bfd *abfd, symindex previous, carsym **sym);
+	symindex bfd_get_next_mapent
+	  (bfd *abfd, symindex previous, carsym **sym);
 
 DESCRIPTION
 	Step through archive @var{abfd}'s symbol table (if it
@@ -214,10 +202,7 @@ DESCRIPTION
 */
 
 symindex
-bfd_get_next_mapent (abfd, prev, entry)
-     bfd *abfd;
-     symindex prev;
-     carsym **entry;
+bfd_get_next_mapent (bfd *abfd, symindex prev, carsym **entry)
 {
   if (!bfd_has_map (abfd))
     {
@@ -239,8 +224,7 @@ bfd_get_next_mapent (abfd, prev, entry)
 /* To be called by backends only */
 
 bfd *
-_bfd_create_empty_archive_element_shell (obfd)
-     bfd *obfd;
+_bfd_create_empty_archive_element_shell (bfd *obfd)
 {
   return _bfd_new_bfd_contained_in (obfd);
 }
@@ -250,7 +234,7 @@ FUNCTION
 	bfd_set_archive_head
 
 SYNOPSIS
-	bfd_boolean bfd_set_archive_head(bfd *output, bfd *new_head);
+	bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);
 
 DESCRIPTION
 	Set the head of the chain of
@@ -258,19 +242,14 @@ DESCRIPTION
 */
 
 bfd_boolean
-bfd_set_archive_head (output_archive, new_head)
-     bfd *output_archive;
-     bfd *new_head;
+bfd_set_archive_head (bfd *output_archive, bfd *new_head)
 {
-
   output_archive->archive_head = new_head;
   return TRUE;
 }
 
 bfd *
-_bfd_look_for_bfd_in_cache (arch_bfd, filepos)
-     bfd *arch_bfd;
-     file_ptr filepos;
+_bfd_look_for_bfd_in_cache (bfd *arch_bfd, file_ptr filepos)
 {
   struct ar_cache *current;
 
@@ -284,19 +263,17 @@ _bfd_look_for_bfd_in_cache (arch_bfd, filepos)
 
 /* Kind of stupid to call cons for each one, but we don't do too many */
 bfd_boolean
-_bfd_add_bfd_to_archive_cache (arch_bfd, filepos, new_elt)
-     bfd *arch_bfd, *new_elt;
-     file_ptr filepos;
+_bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt)
 {
   bfd_size_type amt = sizeof (struct ar_cache);
 
-  struct ar_cache *new_cache = (struct ar_cache *) bfd_zalloc (arch_bfd, amt);
+  struct ar_cache *new_cache = bfd_zalloc (arch_bfd, amt);
   if (new_cache == NULL)
     return FALSE;
 
   new_cache->ptr = filepos;
   new_cache->arelt = new_elt;
-  new_cache->next = (struct ar_cache *) NULL;
+  new_cache->next = NULL;
   if (bfd_ardata (arch_bfd)->cache == NULL)
     bfd_ardata (arch_bfd)->cache = new_cache;
   else
@@ -315,9 +292,7 @@ _bfd_add_bfd_to_archive_cache (arch_bfd, filepos, new_elt)
    the string table.  */
 
 static char *
-get_extended_arelt_filename (arch, name)
-     bfd *arch;
-     const char *name;
+get_extended_arelt_filename (bfd *arch, const char *name)
 {
   unsigned long index = 0;
 
@@ -344,20 +319,17 @@ get_extended_arelt_filename (arch, name)
    could have been moved arbitrarily.
 */
 
-PTR
-_bfd_generic_read_ar_hdr (abfd)
-     bfd *abfd;
+void *
+_bfd_generic_read_ar_hdr (bfd *abfd)
 {
-  return _bfd_generic_read_ar_hdr_mag (abfd, (const char *) NULL);
+  return _bfd_generic_read_ar_hdr_mag (abfd, NULL);
 }
 
 /* Alpha ECOFF uses an optional different ARFMAG value, so we have a
    variant of _bfd_generic_read_ar_hdr which accepts a magic string.  */
 
-PTR
-_bfd_generic_read_ar_hdr_mag (abfd, mag)
-     bfd *abfd;
-     const char *mag;
+void *
+_bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
 {
   struct ar_hdr hdr;
   char *hdrp = (char *) &hdr;
@@ -368,8 +340,7 @@ _bfd_generic_read_ar_hdr_mag (abfd, mag)
   bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
   char *allocptr = 0;
 
-  if (bfd_bread ((PTR) hdrp, (bfd_size_type) sizeof (struct ar_hdr), abfd)
-      != sizeof (struct ar_hdr))
+  if (bfd_bread (hdrp, sizeof (struct ar_hdr), abfd) != sizeof (struct ar_hdr))
     {
       if (bfd_get_error () != bfd_error_system_call)
 	bfd_set_error (bfd_error_no_more_archived_files);
@@ -439,12 +410,12 @@ _bfd_generic_read_ar_hdr_mag (abfd, mag)
 	 spaces, so only look for ' ' if we don't find '/'.  */
 
       char *e;
-      e = (char *) memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
+      e = memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
       if (e == NULL)
 	{
-	  e = (char *) memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
+	  e = memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
 	  if (e == NULL)
-	    e = (char *) memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
+	    e = memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
 	}
 
       if (e != NULL)
@@ -469,7 +440,7 @@ _bfd_generic_read_ar_hdr_mag (abfd, mag)
   ared = (struct areltdata *) allocptr;
 
   ared->arch_header = allocptr + sizeof (struct areltdata);
-  memcpy ((char *) ared->arch_header, (char *) &hdr, sizeof (struct ar_hdr));
+  memcpy (ared->arch_header, &hdr, sizeof (struct ar_hdr));
   ared->parsed_size = parsed_size;
 
   if (filename != NULL)
@@ -479,11 +450,11 @@ _bfd_generic_read_ar_hdr_mag (abfd, mag)
       ared->filename = allocptr + (sizeof (struct areltdata) +
 				   sizeof (struct ar_hdr));
       if (namelen)
-	memcpy (ared->filename, hdr.ar_name, (size_t) namelen);
+	memcpy (ared->filename, hdr.ar_name, namelen);
       ared->filename[namelen] = '\0';
     }
 
-  return (PTR) ared;
+  return ared;
 }
 
 /* This is an internal function; it's mainly used when indexing
@@ -491,9 +462,7 @@ _bfd_generic_read_ar_hdr_mag (abfd, mag)
    element, since it handles the bookkeeping so nicely for us.  */
 
 bfd *
-_bfd_get_elt_at_filepos (archive, filepos)
-     bfd *archive;
-     file_ptr filepos;
+_bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos)
 {
   struct areltdata *new_areldata;
   bfd *n_nfd;
@@ -505,26 +474,26 @@ _bfd_get_elt_at_filepos (archive, filepos)
   if (0 > bfd_seek (archive, filepos, SEEK_SET))
     return NULL;
 
-  if ((new_areldata = (struct areltdata *) _bfd_read_ar_hdr (archive)) == NULL)
+  if ((new_areldata = _bfd_read_ar_hdr (archive)) == NULL)
     return NULL;
 
   n_nfd = _bfd_create_empty_archive_element_shell (archive);
   if (n_nfd == NULL)
     {
-      bfd_release (archive, (PTR) new_areldata);
+      bfd_release (archive, new_areldata);
       return NULL;
     }
 
   n_nfd->origin = bfd_tell (archive);
-  n_nfd->arelt_data = (PTR) new_areldata;
+  n_nfd->arelt_data = new_areldata;
   n_nfd->filename = new_areldata->filename;
 
   if (_bfd_add_bfd_to_archive_cache (archive, filepos, n_nfd))
     return n_nfd;
 
   /* Huh?  */
-  bfd_release (archive, (PTR) n_nfd);
-  bfd_release (archive, (PTR) new_areldata);
+  bfd_release (archive, n_nfd);
+  bfd_release (archive, new_areldata);
   return NULL;
 }
 
@@ -532,9 +501,7 @@ _bfd_get_elt_at_filepos (archive, filepos)
    INDEX.  INDEX should have been returned by bfd_get_next_mapent.  */
 
 bfd *
-_bfd_generic_get_elt_at_index (abfd, index)
-     bfd *abfd;
-     symindex index;
+_bfd_generic_get_elt_at_index (bfd *abfd, symindex index)
 {
   carsym *entry;
 
@@ -547,7 +514,7 @@ FUNCTION
 	bfd_openr_next_archived_file
 
 SYNOPSIS
-	bfd *bfd_openr_next_archived_file(bfd *archive, bfd *previous);
+	bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous);
 
 DESCRIPTION
 	Provided a BFD, @var{archive}, containing an archive and NULL, open
@@ -559,9 +526,7 @@ DESCRIPTION
 */
 
 bfd *
-bfd_openr_next_archived_file (archive, last_file)
-     bfd *archive;
-     bfd *last_file;
+bfd_openr_next_archived_file (bfd *archive, bfd *last_file)
 {
   if ((bfd_get_format (archive) != bfd_archive) ||
       (archive->direction == write_direction))
@@ -571,15 +536,11 @@ bfd_openr_next_archived_file (archive, last_file)
     }
 
   return BFD_SEND (archive,
-		   openr_next_archived_file,
-		   (archive,
-		    last_file));
+		   openr_next_archived_file, (archive, last_file));
 }
 
 bfd *
-bfd_generic_openr_next_archived_file (archive, last_file)
-     bfd *archive;
-     bfd *last_file;
+bfd_generic_openr_next_archived_file (bfd *archive, bfd *last_file)
 {
   file_ptr filestart;
 
@@ -599,14 +560,13 @@ bfd_generic_openr_next_archived_file (archive, last_file)
 }
 
 const bfd_target *
-bfd_generic_archive_p (abfd)
-     bfd *abfd;
+bfd_generic_archive_p (bfd *abfd)
 {
   struct artdata *tdata_hold;
   char armag[SARMAG + 1];
   bfd_size_type amt;
 
-  if (bfd_bread ((PTR) armag, (bfd_size_type) SARMAG, abfd) != SARMAG)
+  if (bfd_bread (armag, SARMAG, abfd) != SARMAG)
     {
       if (bfd_get_error () != bfd_error_system_call)
 	bfd_set_error (bfd_error_wrong_format);
@@ -625,7 +585,7 @@ bfd_generic_archive_p (abfd)
   tdata_hold = bfd_ardata (abfd);
 
   amt = sizeof (struct artdata);
-  bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
+  bfd_ardata (abfd) = bfd_zalloc (abfd, amt);
   if (bfd_ardata (abfd) == NULL)
     {
       bfd_ardata (abfd) = tdata_hold;
@@ -664,7 +624,7 @@ bfd_generic_archive_p (abfd)
 	 normal archive, regardless of the format of the object files.
 	 We do accept an empty archive.  */
 
-      first = bfd_openr_next_archived_file (abfd, (bfd *) NULL);
+      first = bfd_openr_next_archived_file (abfd, NULL);
       if (first != NULL)
 	{
 	  bfd_boolean fail;
@@ -679,7 +639,7 @@ bfd_generic_archive_p (abfd)
 		 we have no way to remove it from the archive cache.
 		 It's close to impossible to figure out when we can
 		 release bfd_ardata.  FIXME.  */
-	      (void) bfd_close (first);
+	      bfd_close (first);
 	      bfd_release (abfd, bfd_ardata (abfd));
 #endif
 	      bfd_set_error (bfd_error_wrong_object_format);
@@ -713,8 +673,7 @@ bfd_generic_archive_p (abfd)
 /* Returns FALSE on error, TRUE otherwise */
 
 static bfd_boolean
-do_slurp_bsd_armap (abfd)
-     bfd *abfd;
+do_slurp_bsd_armap (bfd *abfd)
 {
   struct areltdata *mapdata;
   unsigned int counter;
@@ -724,22 +683,22 @@ do_slurp_bsd_armap (abfd)
   bfd_size_type parsed_size, amt;
   carsym *set;
 
-  mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
+  mapdata = _bfd_read_ar_hdr (abfd);
   if (mapdata == NULL)
     return FALSE;
   parsed_size = mapdata->parsed_size;
-  bfd_release (abfd, (PTR) mapdata);	/* Don't need it any more.  */
+  bfd_release (abfd, mapdata);	/* Don't need it any more.  */
 
-  raw_armap = (bfd_byte *) bfd_zalloc (abfd, parsed_size);
-  if (raw_armap == (bfd_byte *) NULL)
+  raw_armap = bfd_zalloc (abfd, parsed_size);
+  if (raw_armap == NULL)
     return FALSE;
 
-  if (bfd_bread ((PTR) raw_armap, parsed_size, abfd) != parsed_size)
+  if (bfd_bread (raw_armap, parsed_size, abfd) != parsed_size)
     {
       if (bfd_get_error () != bfd_error_system_call)
 	bfd_set_error (bfd_error_malformed_archive);
     byebye:
-      bfd_release (abfd, (PTR) raw_armap);
+      bfd_release (abfd, raw_armap);
       return FALSE;
     }
 
@@ -758,8 +717,8 @@ do_slurp_bsd_armap (abfd)
   stringbase = ((char *) rbase
 		+ ardata->symdef_count * BSD_SYMDEF_SIZE
 		+ BSD_STRING_COUNT_SIZE);
-  amt = (bfd_size_type) ardata->symdef_count * sizeof (carsym);
-  ardata->symdefs = (carsym *) bfd_alloc (abfd, amt);
+  amt = ardata->symdef_count * sizeof (carsym);
+  ardata->symdefs = bfd_alloc (abfd, amt);
   if (!ardata->symdefs)
     return FALSE;
 
@@ -784,8 +743,7 @@ do_slurp_bsd_armap (abfd)
 /* Returns FALSE on error, TRUE otherwise.  */
 
 static bfd_boolean
-do_slurp_coff_armap (abfd)
-     bfd *abfd;
+do_slurp_coff_armap (bfd *abfd)
 {
   struct areltdata *mapdata;
   int *raw_armap, *rawptr;
@@ -795,18 +753,18 @@ do_slurp_coff_armap (abfd)
   unsigned int parsed_size;
   carsym *carsyms;
   bfd_size_type nsymz;		/* Number of symbols in armap.  */
-  bfd_vma (*swap) PARAMS ((const bfd_byte *));
+  bfd_vma (*swap) (const bfd_byte *);
   char int_buf[sizeof (long)];
   bfd_size_type carsym_size, ptrsize;
   unsigned int i;
 
-  mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
+  mapdata = _bfd_read_ar_hdr (abfd);
   if (mapdata == NULL)
     return FALSE;
   parsed_size = mapdata->parsed_size;
-  bfd_release (abfd, (PTR) mapdata);	/* Don't need it any more.  */
+  bfd_release (abfd, mapdata);	/* Don't need it any more.  */
 
-  if (bfd_bread ((PTR) int_buf, (bfd_size_type) 4, abfd) != 4)
+  if (bfd_bread (int_buf, 4, abfd) != 4)
     {
       if (bfd_get_error () != bfd_error_system_call)
 	bfd_set_error (bfd_error_malformed_archive);
@@ -815,7 +773,7 @@ do_slurp_coff_armap (abfd)
   /* It seems that all numeric information in a coff archive is always
      in big endian format, nomatter the host or target.  */
   swap = bfd_getb32;
-  nsymz = bfd_getb32 ((PTR) int_buf);
+  nsymz = bfd_getb32 (int_buf);
   stringsize = parsed_size - (4 * nsymz) - 4;
 
 #if 1
@@ -829,7 +787,7 @@ do_slurp_coff_armap (abfd)
       && bfd_get_flavour (abfd) == bfd_target_coff_flavour)
     {
       /* This looks dangerous, let's do it the other way around.  */
-      nsymz = bfd_getl32 ((PTR) int_buf);
+      nsymz = bfd_getl32 (int_buf);
       stringsize = parsed_size - (4 * nsymz) - 4;
       swap = bfd_getl32;
     }
@@ -841,18 +799,18 @@ do_slurp_coff_armap (abfd)
   carsym_size = (nsymz * sizeof (carsym));
   ptrsize = (4 * nsymz);
 
-  ardata->symdefs = (carsym *) bfd_zalloc (abfd, carsym_size + stringsize + 1);
+  ardata->symdefs = bfd_zalloc (abfd, carsym_size + stringsize + 1);
   if (ardata->symdefs == NULL)
     return FALSE;
   carsyms = ardata->symdefs;
   stringbase = ((char *) ardata->symdefs) + carsym_size;
 
   /* Allocate and read in the raw offsets.  */
-  raw_armap = (int *) bfd_alloc (abfd, ptrsize);
+  raw_armap = bfd_alloc (abfd, ptrsize);
   if (raw_armap == NULL)
     goto release_symdefs;
-  if (bfd_bread ((PTR) raw_armap, ptrsize, abfd) != ptrsize
-      || (bfd_bread ((PTR) stringbase, stringsize, abfd) != stringsize))
+  if (bfd_bread (raw_armap, ptrsize, abfd) != ptrsize
+      || (bfd_bread (stringbase, stringsize, abfd) != stringsize))
     {
       if (bfd_get_error () != bfd_error_system_call)
 	bfd_set_error (bfd_error_malformed_archive);
@@ -863,7 +821,7 @@ do_slurp_coff_armap (abfd)
   for (i = 0; i < nsymz; i++)
     {
       rawptr = raw_armap + i;
-      carsyms->file_offset = swap ((PTR) rawptr);
+      carsyms->file_offset = swap ((bfd_byte *) rawptr);
       carsyms->name = stringbase;
       stringbase += strlen (stringbase) + 1;
       carsyms++;
@@ -876,14 +834,14 @@ do_slurp_coff_armap (abfd)
   ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
 
   bfd_has_map (abfd) = TRUE;
-  bfd_release (abfd, (PTR) raw_armap);
+  bfd_release (abfd, raw_armap);
 
   /* Check for a second archive header (as used by PE).  */
   {
     struct areltdata *tmp;
 
     bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET);
-    tmp = (struct areltdata *) _bfd_read_ar_hdr (abfd);
+    tmp = _bfd_read_ar_hdr (abfd);
     if (tmp != NULL)
       {
 	if (tmp->arch_header[0] == '/'
@@ -899,9 +857,9 @@ do_slurp_coff_armap (abfd)
   return TRUE;
 
 release_raw_armap:
-  bfd_release (abfd, (PTR) raw_armap);
+  bfd_release (abfd, raw_armap);
 release_symdefs:
-  bfd_release (abfd, (PTR) (ardata)->symdefs);
+  bfd_release (abfd, (ardata)->symdefs);
   return FALSE;
 }
 
@@ -909,11 +867,10 @@ release_symdefs:
    Returns FALSE on error, TRUE otherwise */
 
 bfd_boolean
-bfd_slurp_armap (abfd)
-     bfd *abfd;
+bfd_slurp_armap (bfd *abfd)
 {
   char nextname[17];
-  int i = bfd_bread ((PTR) nextname, (bfd_size_type) 16, abfd);
+  int i = bfd_bread (nextname, 16, abfd);
 
   if (i == 0)
     return TRUE;
@@ -932,6 +889,7 @@ bfd_slurp_armap (abfd)
     {
       /* 64bit ELF (Irix 6) archive.  */
 #ifdef BFD64
+      extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *);
       return bfd_elf64_archive_slurp_armap (abfd);
 #else
       bfd_set_error (bfd_error_wrong_format);
@@ -951,8 +909,7 @@ bfd_slurp_armap (abfd)
 #define HPUX_SYMDEF_COUNT_SIZE 2
 
 bfd_boolean
-bfd_slurp_bsd_armap_f2 (abfd)
-     bfd *abfd;
+bfd_slurp_bsd_armap_f2 (bfd *abfd)
 {
   struct areltdata *mapdata;
   char nextname[17];
@@ -963,7 +920,7 @@ bfd_slurp_bsd_armap_f2 (abfd)
   unsigned int stringsize;
   bfd_size_type amt;
   carsym *set;
-  int i = bfd_bread ((PTR) nextname, (bfd_size_type) 16, abfd);
+  int i = bfd_bread (nextname, 16, abfd);
 
   if (i == 0)
     return TRUE;
@@ -984,29 +941,29 @@ bfd_slurp_bsd_armap_f2 (abfd)
       return TRUE;
     }
 
-  mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
+  mapdata = _bfd_read_ar_hdr (abfd);
   if (mapdata == NULL)
     return FALSE;
 
   amt = mapdata->parsed_size;
-  raw_armap = (bfd_byte *) bfd_zalloc (abfd, amt);
+  raw_armap = bfd_zalloc (abfd, amt);
   if (raw_armap == NULL)
     {
     byebye:
-      bfd_release (abfd, (PTR) mapdata);
+      bfd_release (abfd, mapdata);
       return FALSE;
     }
 
-  if (bfd_bread ((PTR) raw_armap, amt, abfd) != amt)
+  if (bfd_bread (raw_armap, amt, abfd) != amt)
     {
       if (bfd_get_error () != bfd_error_system_call)
 	bfd_set_error (bfd_error_malformed_archive);
     byebyebye:
-      bfd_release (abfd, (PTR) raw_armap);
+      bfd_release (abfd, raw_armap);
       goto byebye;
     }
 
-  ardata->symdef_count = H_GET_16 (abfd, (PTR) raw_armap);
+  ardata->symdef_count = H_GET_16 (abfd, raw_armap);
 
   if (ardata->symdef_count * BSD_SYMDEF_SIZE
       > mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE)
@@ -1024,8 +981,8 @@ bfd_slurp_bsd_armap_f2 (abfd)
 		+ HPUX_SYMDEF_COUNT_SIZE
 		+ BSD_STRING_COUNT_SIZE);
   rbase = (bfd_byte *) stringbase + stringsize;
-  amt = (bfd_size_type) ardata->symdef_count * BSD_SYMDEF_SIZE;
-  ardata->symdefs = (carsym *) bfd_alloc (abfd, amt);
+  amt = ardata->symdef_count * BSD_SYMDEF_SIZE;
+  ardata->symdefs = bfd_alloc (abfd, amt);
   if (!ardata->symdefs)
     return FALSE;
 
@@ -1060,8 +1017,7 @@ bfd_slurp_bsd_armap_f2 (abfd)
 /* Returns FALSE on error, TRUE otherwise.  */
 
 bfd_boolean
-_bfd_slurp_extended_name_table (abfd)
-     bfd *abfd;
+_bfd_slurp_extended_name_table (bfd *abfd)
 {
   char nextname[17];
   struct areltdata *namedata;
@@ -1070,7 +1026,7 @@ _bfd_slurp_extended_name_table (abfd)
   /* FIXME:  Formatting sucks here, and in case of failure of BFD_READ,
      we probably don't want to return TRUE.  */
   bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET);
-  if (bfd_bread ((PTR) nextname, (bfd_size_type) 16, abfd) == 16)
+  if (bfd_bread (nextname, 16, abfd) == 16)
     {
       if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
 	return FALSE;
@@ -1082,7 +1038,7 @@ _bfd_slurp_extended_name_table (abfd)
 	  return TRUE;
 	}
 
-      namedata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
+      namedata = _bfd_read_ar_hdr (abfd);
       if (namedata == NULL)
 	return FALSE;
 
@@ -1091,15 +1047,15 @@ _bfd_slurp_extended_name_table (abfd)
       if (bfd_ardata (abfd)->extended_names == NULL)
 	{
 	byebye:
-	  bfd_release (abfd, (PTR) namedata);
+	  bfd_release (abfd, namedata);
 	  return FALSE;
 	}
 
-      if (bfd_bread ((PTR) bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
+      if (bfd_bread (bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
 	{
 	  if (bfd_get_error () != bfd_error_system_call)
 	    bfd_set_error (bfd_error_malformed_archive);
-	  bfd_release (abfd, (PTR) (bfd_ardata (abfd)->extended_names));
+	  bfd_release (abfd, (bfd_ardata (abfd)->extended_names));
 	  bfd_ardata (abfd)->extended_names = NULL;
 	  goto byebye;
 	}
@@ -1141,9 +1097,7 @@ _bfd_slurp_extended_name_table (abfd)
    semicolon.  */
 
 static const char *
-normalize (abfd, file)
-     bfd *abfd;
-     const char *file;
+normalize (bfd *abfd, const char *file)
 {
   const char *first;
   const char *last;
@@ -1164,7 +1118,7 @@ normalize (abfd, file)
       first--;
     }
 
-  copy = (char *) bfd_alloc (abfd, (bfd_size_type) (last - first + 1));
+  copy = bfd_alloc (abfd, last - first + 1);
   if (copy == NULL)
     return NULL;
 
@@ -1176,9 +1130,7 @@ normalize (abfd, file)
 
 #else
 static const char *
-normalize (abfd, file)
-     bfd *abfd ATTRIBUTE_UNUSED;
-     const char *file;
+normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file)
 {
   const char *filename = strrchr (file, '/');
 
@@ -1192,7 +1144,7 @@ normalize (abfd, file)
       filename = file + 1;
   }
 #endif
-  if (filename != (char *) NULL)
+  if (filename != NULL)
     filename++;
   else
     filename = file;
@@ -1203,11 +1155,10 @@ normalize (abfd, file)
 /* Build a BFD style extended name table.  */
 
 bfd_boolean
-_bfd_archive_bsd_construct_extended_name_table (abfd, tabloc, tablen, name)
-     bfd *abfd;
-     char **tabloc;
-     bfd_size_type *tablen;
-     const char **name;
+_bfd_archive_bsd_construct_extended_name_table (bfd *abfd,
+						char **tabloc,
+						bfd_size_type *tablen,
+						const char **name)
 {
   *name = "ARFILENAMES/";
   return _bfd_construct_extended_name_table (abfd, FALSE, tabloc, tablen);
@@ -1216,11 +1167,10 @@ _bfd_archive_bsd_construct_extended_name_table (abfd, tabloc, tablen, name)
 /* Build an SVR4 style extended name table.  */
 
 bfd_boolean
-_bfd_archive_coff_construct_extended_name_table (abfd, tabloc, tablen, name)
-     bfd *abfd;
-     char **tabloc;
-     bfd_size_type *tablen;
-     const char **name;
+_bfd_archive_coff_construct_extended_name_table (bfd *abfd,
+						 char **tabloc,
+						 bfd_size_type *tablen,
+						 const char **name)
 {
   *name = "//";
   return _bfd_construct_extended_name_table (abfd, TRUE, tabloc, tablen);
@@ -1235,11 +1185,10 @@ _bfd_archive_coff_construct_extended_name_table (abfd, tabloc, tablen, name)
    zero-length tablen!  */
 
 bfd_boolean
-_bfd_construct_extended_name_table (abfd, trailing_slash, tabloc, tablen)
-     bfd *abfd;
-     bfd_boolean trailing_slash;
-     char **tabloc;
-     bfd_size_type *tablen;
+_bfd_construct_extended_name_table (bfd *abfd,
+				    bfd_boolean trailing_slash,
+				    char **tabloc,
+				    bfd_size_type *tablen)
 {
   unsigned int maxname = abfd->xvec->ar_max_namelen;
   bfd_size_type total_namelen = 0;
@@ -1353,9 +1302,7 @@ _bfd_construct_extended_name_table (abfd, trailing_slash, tabloc, tablen)
 /* Function to encode large UID/GID values according to HP.  */
 
 static void
-hpux_uid_gid_encode (str, id)
-     char str[6];
-     long int id;
+hpux_uid_gid_encode (char str[6], long int id)
 {
   int cnt;
 
@@ -1381,10 +1328,7 @@ hpux_uid_gid_encode (str, id)
    is set, and it's an in-memory bfd, we fake it.  */
 
 static struct areltdata *
-bfd_ar_hdr_from_filesystem (abfd, filename, member)
-     bfd *abfd;
-     const char *filename;
-     bfd *member;
+bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
 {
   struct stat status;
   struct areltdata *ared;
@@ -1395,7 +1339,7 @@ bfd_ar_hdr_from_filesystem (abfd, filename, member)
   if (member && (member->flags & BFD_IN_MEMORY) != 0)
     {
       /* Assume we just "made" the member, and fake it.  */
-      struct bfd_in_memory *bim = (struct bfd_in_memory *) member->iostream;
+      struct bfd_in_memory *bim = member->iostream;
       time (&status.st_mtime);
       status.st_uid = getuid ();
       status.st_gid = getgid ();
@@ -1409,13 +1353,13 @@ bfd_ar_hdr_from_filesystem (abfd, filename, member)
     }
 
   amt = sizeof (struct ar_hdr) + sizeof (struct areltdata);
-  ared = (struct areltdata *) bfd_zalloc (abfd, amt);
+  ared = bfd_zalloc (abfd, amt);
   if (ared == NULL)
     return NULL;
   hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));
 
   /* ar headers are space padded, not null padded!  */
-  memset ((PTR) hdr, ' ', sizeof (struct ar_hdr));
+  memset (hdr, ' ', sizeof (struct ar_hdr));
 
   strncpy (hdr->ar_fmag, ARFMAG, 2);
 
@@ -1461,13 +1405,10 @@ bfd_ar_hdr_from_filesystem (abfd, filename, member)
    a strong stomach to write this, and it does, but it takes even a
    stronger stomach to try to code around such a thing!  */
 
-struct ar_hdr *bfd_special_undocumented_glue
-  PARAMS ((bfd *, const char *));
+struct ar_hdr *bfd_special_undocumented_glue (bfd *, const char *);
 
 struct ar_hdr *
-bfd_special_undocumented_glue (abfd, filename)
-     bfd *abfd;
-     const char *filename;
+bfd_special_undocumented_glue (bfd *abfd, const char *filename)
 {
   struct areltdata *ar_elt = bfd_ar_hdr_from_filesystem (abfd, filename, 0);
   if (ar_elt == NULL)
@@ -1478,9 +1419,7 @@ bfd_special_undocumented_glue (abfd, filename)
 /* Analogous to stat call.  */
 
 int
-bfd_generic_stat_arch_elt (abfd, buf)
-     bfd *abfd;
-     struct stat *buf;
+bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
 {
   struct ar_hdr *hdr;
   char *aloser;
@@ -1535,10 +1474,7 @@ bfd_generic_stat_arch_elt (abfd, buf)
 }
 
 void
-bfd_dont_truncate_arname (abfd, pathname, arhdr)
-     bfd *abfd;
-     const char *pathname;
-     char *arhdr;
+bfd_dont_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
 {
   /* FIXME: This interacts unpleasantly with ar's quick-append option.
      Fortunately ic960 users will never use that option.  Fixing this
@@ -1575,10 +1511,7 @@ bfd_dont_truncate_arname (abfd, pathname, arhdr)
 }
 
 void
-bfd_bsd_truncate_arname (abfd, pathname, arhdr)
-     bfd *abfd;
-     const char *pathname;
-     char *arhdr;
+bfd_bsd_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
 {
   struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
   size_t length;
@@ -1626,10 +1559,7 @@ bfd_bsd_truncate_arname (abfd, pathname, arhdr)
    bsd ar.  */
 
 void
-bfd_gnu_truncate_arname (abfd, pathname, arhdr)
-     bfd *abfd;
-     const char *pathname;
-     char *arhdr;
+bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
 {
   struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
   size_t length;
@@ -1674,8 +1604,7 @@ bfd_gnu_truncate_arname (abfd, pathname, arhdr)
 /* The BFD is open for write and has its format set to bfd_archive.  */
 
 bfd_boolean
-_bfd_write_archive_contents (arch)
-     bfd *arch;
+_bfd_write_archive_contents (bfd *arch)
 {
   bfd *current;
   char *etable = NULL;
@@ -1706,14 +1635,13 @@ _bfd_write_archive_contents (arch)
       if (!current->arelt_data)
 	{
 	  current->arelt_data =
-	    (PTR) bfd_ar_hdr_from_filesystem (arch, current->filename, current);
+	    bfd_ar_hdr_from_filesystem (arch, current->filename, current);
 	  if (!current->arelt_data)
 	    return FALSE;
 
 	  /* Put in the file name.  */
-	  BFD_SEND (arch, _bfd_truncate_arname, (arch,
-						 current->filename,
-					      (char *) arch_hdr (current)));
+	  BFD_SEND (arch, _bfd_truncate_arname,
+		    (arch, current->filename, (char *) arch_hdr (current)));
 	}
 
       if (makemap && ! hasobjects)
@@ -1734,9 +1662,9 @@ _bfd_write_archive_contents (arch)
   if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0)
     return FALSE;
 #ifdef GNU960
-  wrote = bfd_bwrite (BFD_GNU960_ARMAG (arch), (bfd_size_type) SARMAG, arch);
+  wrote = bfd_bwrite (BFD_GNU960_ARMAG (arch), SARMAG, arch);
 #else
-  wrote = bfd_bwrite (ARMAG, (bfd_size_type) SARMAG, arch);
+  wrote = bfd_bwrite (ARMAG, SARMAG, arch);
 #endif
   if (wrote != SARMAG)
     return FALSE;
@@ -1751,7 +1679,7 @@ _bfd_write_archive_contents (arch)
     {
       struct ar_hdr hdr;
 
-      memset ((char *) (&hdr), 0, sizeof (struct ar_hdr));
+      memset (&hdr, 0, sizeof (struct ar_hdr));
       strcpy (hdr.ar_name, ename);
       /* Round size up to even number in archive header.  */
       sprintf (&(hdr.ar_size[0]), "%-10d",
@@ -1760,13 +1688,13 @@ _bfd_write_archive_contents (arch)
       for (i = 0; i < sizeof (struct ar_hdr); i++)
 	if (((char *) (&hdr))[i] == '\0')
 	  (((char *) (&hdr))[i]) = ' ';
-      if ((bfd_bwrite ((PTR) &hdr, (bfd_size_type) sizeof (struct ar_hdr), arch)
+      if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
 	   != sizeof (struct ar_hdr))
 	  || bfd_bwrite (etable, elength, arch) != elength)
 	return FALSE;
       if ((elength % 2) == 1)
 	{
-	  if (bfd_bwrite ("\012", (bfd_size_type) 1, arch) != 1)
+	  if (bfd_bwrite ("\012", 1, arch) != 1)
 	    return FALSE;
 	}
     }
@@ -1778,7 +1706,7 @@ _bfd_write_archive_contents (arch)
       struct ar_hdr *hdr = arch_hdr (current);
 
       /* Write ar header.  */
-      if (bfd_bwrite ((PTR) hdr, (bfd_size_type) sizeof (*hdr), arch)
+      if (bfd_bwrite (hdr, sizeof (*hdr), arch)
 	  != sizeof (*hdr))
 	return FALSE;
       if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
@@ -1789,19 +1717,19 @@ _bfd_write_archive_contents (arch)
 	  if (amt > remaining)
 	    amt = remaining;
 	  errno = 0;
-	  if (bfd_bread (buffer, (bfd_size_type) amt, current) != amt)
+	  if (bfd_bread (buffer, amt, current) != amt)
 	    {
 	      if (bfd_get_error () != bfd_error_system_call)
 		bfd_set_error (bfd_error_malformed_archive);
 	      return FALSE;
 	    }
-	  if (bfd_bwrite (buffer, (bfd_size_type) amt, arch) != amt)
+	  if (bfd_bwrite (buffer, amt, arch) != amt)
 	    return FALSE;
 	  remaining -= amt;
 	}
       if ((arelt_size (current) % 2) == 1)
 	{
-	  if (bfd_bwrite ("\012", (bfd_size_type) 1, arch) != 1)
+	  if (bfd_bwrite ("\012", 1, arch) != 1)
 	    return FALSE;
 	}
     }
@@ -1831,9 +1759,7 @@ _bfd_write_archive_contents (arch)
 /* Note that the namidx for the first symbol is 0.  */
 
 bfd_boolean
-_bfd_compute_and_write_armap (arch, elength)
-     bfd *arch;
-     unsigned int elength;
+_bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
 {
   char *first_name = NULL;
   bfd *current;
@@ -1852,14 +1778,14 @@ _bfd_compute_and_write_armap (arch, elength)
     elength += sizeof (struct ar_hdr);
   elength += elength % 2;
 
-  amt = (bfd_size_type) orl_max * sizeof (struct orl);
-  map = (struct orl *) bfd_malloc (amt);
+  amt = orl_max * sizeof (struct orl);
+  map = bfd_malloc (amt);
   if (map == NULL)
     goto error_return;
 
   /* We put the symbol names on the arch objalloc, and then discard
      them when done.  */
-  first_name = bfd_alloc (arch, (bfd_size_type) 1);
+  first_name = bfd_alloc (arch, 1);
   if (first_name == NULL)
     goto error_return;
 
@@ -1870,7 +1796,7 @@ _bfd_compute_and_write_armap (arch, elength)
 
   /* Map over each element.  */
   for (current = arch->archive_head;
-       current != (bfd *) NULL;
+       current != NULL;
        current = current->next, elt_no++)
     {
       if (bfd_check_format (current, bfd_object)
@@ -1891,7 +1817,7 @@ _bfd_compute_and_write_armap (arch, elength)
 		  if (syms_max > 0)
 		    free (syms);
 		  syms_max = storage;
-		  syms = (asymbol **) bfd_malloc ((bfd_size_type) syms_max);
+		  syms = bfd_malloc (syms_max);
 		  if (syms == NULL)
 		    goto error_return;
 		}
@@ -1919,9 +1845,9 @@ _bfd_compute_and_write_armap (arch, elength)
 		      if (orl_count == orl_max)
 			{
 			  orl_max *= 2;
-			  amt = (bfd_size_type) orl_max * sizeof (struct orl);
-			  new_map = (struct orl *) bfd_realloc (map, amt);
-			  if (new_map == (struct orl *) NULL)
+			  amt = orl_max * sizeof (struct orl);
+			  new_map = bfd_realloc (map, amt);
+			  if (new_map == NULL)
 			    goto error_return;
 
 			  map = new_map;
@@ -1929,7 +1855,7 @@ _bfd_compute_and_write_armap (arch, elength)
 
 		      namelen = strlen (syms[src_count]->name);
 		      amt = sizeof (char *);
-		      map[orl_count].name = (char **) bfd_alloc (arch, amt);
+		      map[orl_count].name = bfd_alloc (arch, amt);
 		      if (map[orl_count].name == NULL)
 			goto error_return;
 		      *(map[orl_count].name) = bfd_alloc (arch, namelen + 1);
@@ -1977,12 +1903,11 @@ _bfd_compute_and_write_armap (arch, elength)
 }
 
 bfd_boolean
-bsd_write_armap (arch, elength, map, orl_count, stridx)
-     bfd *arch;
-     unsigned int elength;
-     struct orl *map;
-     unsigned int orl_count;
-     int stridx;
+bsd_write_armap (bfd *arch,
+		 unsigned int elength,
+		 struct orl *map,
+		 unsigned int orl_count,
+		 int stridx)
 {
   int padit = stridx & 1;
   unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE;
@@ -2001,7 +1926,7 @@ bsd_write_armap (arch, elength, map, orl_count, stridx)
   firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
 
   stat (arch->filename, &statbuf);
-  memset ((char *) (&hdr), 0, sizeof (struct ar_hdr));
+  memset (&hdr, 0, sizeof (struct ar_hdr));
   sprintf (hdr.ar_name, RANLIBMAG);
   /* Remember the timestamp, to keep it holy.  But fudge it a little.  */
   bfd_ardata (arch)->armap_timestamp = statbuf.st_mtime + ARMAP_TIME_OFFSET;
@@ -2015,11 +1940,11 @@ bsd_write_armap (arch, elength, map, orl_count, stridx)
   for (i = 0; i < sizeof (struct ar_hdr); i++)
     if (((char *) (&hdr))[i] == '\0')
       (((char *) (&hdr))[i]) = ' ';
-  if (bfd_bwrite ((PTR) &hdr, (bfd_size_type) sizeof (struct ar_hdr), arch)
+  if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
       != sizeof (struct ar_hdr))
     return FALSE;
   H_PUT_32 (arch, ranlibsize, temp);
-  if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), arch) != sizeof (temp))
+  if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
     return FALSE;
 
   for (count = 0; count < orl_count; count++)
@@ -2040,20 +1965,20 @@ bsd_write_armap (arch, elength, map, orl_count, stridx)
       last_elt = current;
       H_PUT_32 (arch, map[count].namidx, buf);
       H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE);
-      if (bfd_bwrite (buf, (bfd_size_type) BSD_SYMDEF_SIZE, arch)
+      if (bfd_bwrite (buf, BSD_SYMDEF_SIZE, arch)
 	  != BSD_SYMDEF_SIZE)
 	return FALSE;
     }
 
   /* Now write the strings themselves.  */
   H_PUT_32 (arch, stringsize, temp);
-  if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), arch) != sizeof (temp))
+  if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
     return FALSE;
   for (count = 0; count < orl_count; count++)
     {
       size_t len = strlen (*map[count].name) + 1;
 
-      if (bfd_bwrite (*map[count].name, (bfd_size_type) len, arch) != len)
+      if (bfd_bwrite (*map[count].name, len, arch) != len)
 	return FALSE;
     }
 
@@ -2061,7 +1986,7 @@ bsd_write_armap (arch, elength, map, orl_count, stridx)
      bug-compatible for sun's ar we use a null.  */
   if (padit)
     {
-      if (bfd_bwrite ("", (bfd_size_type) 1, arch) != 1)
+      if (bfd_bwrite ("", 1, arch) != 1)
 	return FALSE;
     }
 
@@ -2075,8 +2000,7 @@ bsd_write_armap (arch, elength, map, orl_count, stridx)
    Return FALSE if we updated the timestamp.  */
 
 bfd_boolean
-_bfd_archive_bsd_update_armap_timestamp (arch)
-     bfd *arch;
+_bfd_archive_bsd_update_armap_timestamp (bfd *arch)
 {
   struct stat archstat;
   struct ar_hdr hdr;
@@ -2110,7 +2034,7 @@ _bfd_archive_bsd_update_armap_timestamp (arch)
   bfd_ardata (arch)->armap_datepos = (SARMAG
 				      + offsetof (struct ar_hdr, ar_date[0]));
   if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0
-      || (bfd_bwrite (hdr.ar_date, (bfd_size_type) sizeof (hdr.ar_date), arch)
+      || (bfd_bwrite (hdr.ar_date, sizeof (hdr.ar_date), arch)
 	  != sizeof (hdr.ar_date)))
     {
       bfd_perror (_("Writing updated armap timestamp"));
@@ -2138,12 +2062,11 @@ _bfd_archive_bsd_update_armap_timestamp (arch)
 */
 
 bfd_boolean
-coff_write_armap (arch, elength, map, symbol_count, stridx)
-     bfd *arch;
-     unsigned int elength;
-     struct orl *map;
-     unsigned int symbol_count;
-     int stridx;
+coff_write_armap (bfd *arch,
+		  unsigned int elength,
+		  struct orl *map,
+		  unsigned int symbol_count,
+		  int stridx)
 {
   /* The size of the ranlib is the number of exported symbols in the
      archive * the number of bytes in an int, + an int for the count.  */
@@ -2166,7 +2089,7 @@ coff_write_armap (arch, elength, map, symbol_count, stridx)
 			     + sizeof (struct ar_hdr)
 			     + SARMAG);
 
-  memset ((char *) (&hdr), 0, sizeof (struct ar_hdr));
+  memset (&hdr, 0, sizeof (struct ar_hdr));
   hdr.ar_name[0] = '/';
   sprintf (hdr.ar_size, "%-10d", (int) mapsize);
   sprintf (hdr.ar_date, "%ld", (long) time (NULL));
@@ -2182,7 +2105,7 @@ coff_write_armap (arch, elength, map, symbol_count, stridx)
 
   /* Write the ar header for this item and the number of symbols.  */
 
-  if (bfd_bwrite ((PTR) &hdr, (bfd_size_type) sizeof (struct ar_hdr), arch)
+  if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
       != sizeof (struct ar_hdr))
     return FALSE;
 
@@ -2197,7 +2120,7 @@ coff_write_armap (arch, elength, map, symbol_count, stridx)
 
   current = arch->archive_head;
   count = 0;
-  while (current != (bfd *) NULL && count < symbol_count)
+  while (current != NULL && count < symbol_count)
     {
       /* For each symbol which is used defined in this object, write
 	 out the object file's address in the archive.  */
@@ -2209,8 +2132,7 @@ coff_write_armap (arch, elength, map, symbol_count, stridx)
 	  count++;
 	}
       /* Add size of this archive entry.  */
-      archive_member_file_ptr += (arelt_size (current)
-				  + sizeof (struct ar_hdr));
+      archive_member_file_ptr += arelt_size (current) + sizeof (struct ar_hdr);
       /* Remember aboout the even alignment.  */
       archive_member_file_ptr += archive_member_file_ptr % 2;
       current = current->next;
@@ -2221,7 +2143,7 @@ coff_write_armap (arch, elength, map, symbol_count, stridx)
     {
       size_t len = strlen (*map[count].name) + 1;
 
-      if (bfd_bwrite (*map[count].name, (bfd_size_type) len, arch) != len)
+      if (bfd_bwrite (*map[count].name, len, arch) != len)
 	return FALSE;
     }
 
@@ -2229,7 +2151,7 @@ coff_write_armap (arch, elength, map, symbol_count, stridx)
      bug-compatible for arc960 we use a null.  */
   if (padit)
     {
-      if (bfd_bwrite ("", (bfd_size_type) 1, arch) != 1)
+      if (bfd_bwrite ("", 1, arch) != 1)
 	return FALSE;
     }