Changeset 618 for trunk/src/binutils/bfd/archive.c

Timestamp:

Aug 16, 2003, 11:33:53 PM (22 years ago)

Author:

bird

Message:

Joined the port of 2.11.2 with 2.14.

File:

• trunk/src/binutils/bfd/archive.c (modified) (98 diffs, 1 prop)

trunk/src/binutils/bfd/archive.c

@@ -1 +1 @@
 /* BFD back-end for archive files (libraries).
    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-   2000
+   2000, 2001, 2002
    Free Software Foundation, Inc.
    Written by Cygnus Support.  Mostly Gumby Henkel-Wallace's fault.
@@ -133 +133 @@
 #include "aout/ar.h"
 #include "aout/ranlib.h"
-#include <ctype.h>
+#include "safe-ctype.h"
 
 #ifndef errno
@@ -141 +141 @@
 #ifdef GNU960
 #define BFD_GNU960_ARMAG(abfd)  (BFD_COFF_FILE_P((abfd)) ? ARMAG : ARMAGB)
-#endif
-
-/* Define offsetof for those systems which lack it */
-
-#ifndef offsetof
-#define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
 #endif
 
@@ -167 +161 @@
 #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 boolean do_slurp_bsd_armap PARAMS ((bfd *abfd));
-static boolean do_slurp_coff_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));
-
-
-boolean
+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));
+
+
+bfd_boolean
 _bfd_generic_mkarchive (abfd)
      bfd *abfd;
 {
-  abfd->tdata.aout_ar_data = ((struct artdata *)
-                              bfd_zalloc (abfd, sizeof (struct artdata)));
-
+  bfd_size_type amt = sizeof (struct artdata);
+
+  abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc (abfd, amt);
   if (bfd_ardata (abfd) == NULL)
-    return false;
+    return FALSE;
 
   bfd_ardata (abfd)->cache = NULL;
@@ -193 +191 @@
   bfd_ardata (abfd)->tdata = NULL;
 
-  return true;
+  return TRUE;
 }
 
@@ -254 +252 @@
 
 SYNOPSIS
-        boolean bfd_set_archive_head(bfd *output, bfd *new_head);
+        bfd_boolean bfd_set_archive_head(bfd *output, bfd *new_head);
 
 DESCRIPTION
@@ -261 +259 @@
 */
 
-boolean
+bfd_boolean
 bfd_set_archive_head (output_archive, new_head)
      bfd *output_archive;
@@ -268 +266 @@
 
   output_archive->archive_head = new_head;
-  return true;
+  return TRUE;
 }
 
@@ -287 +285 @@
 
 /* Kind of stupid to call cons for each one, but we don't do too many */
-boolean
+bfd_boolean
 _bfd_add_bfd_to_archive_cache (arch_bfd, filepos, new_elt)
      bfd *arch_bfd, *new_elt;
      file_ptr filepos;
 {
-  struct ar_cache *new_cache = ((struct ar_cache *)
-                                bfd_zalloc (arch_bfd,
-                                            sizeof (struct ar_cache)));
-
+  bfd_size_type amt = sizeof (struct ar_cache);
+
+  struct ar_cache *new_cache = (struct ar_cache *) bfd_zalloc (arch_bfd, amt);
   if (new_cache == NULL)
-    return false;
+    return FALSE;
 
   new_cache->ptr = filepos;
@@ -313 +310 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -367 +364 @@
   struct ar_hdr hdr;
   char *hdrp = (char *) &hdr;
-  unsigned int parsed_size;
+  size_t parsed_size;
   struct areltdata *ared;
   char *filename = NULL;
-  unsigned int namelen = 0;
-  unsigned int allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
+  bfd_size_type namelen = 0;
+  bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
   char *allocptr = 0;
 
-  if (bfd_read ((PTR) hdrp, 1, sizeof (struct ar_hdr), abfd)
+  if (bfd_bread ((PTR) hdrp, (bfd_size_type) sizeof (struct ar_hdr), abfd)
       != sizeof (struct ar_hdr))
     {
@@ -417 +414 @@
            && hdr.ar_name[1] == '1'
            && hdr.ar_name[2] == '/'
-           && isdigit ((unsigned char) hdr.ar_name[3]))
+           && ISDIGIT (hdr.ar_name[3]))
     {
       /* BSD-4.4 extended name */
@@ -430 +427 @@
                   + sizeof (struct areltdata)
                   + sizeof (struct ar_hdr));
-      if (bfd_read (filename, 1, namelen, abfd) != namelen)
+      if (bfd_bread (filename, namelen, abfd) != namelen)
         {
           if (bfd_get_error () != bfd_error_system_call)
@@ -445 +442 @@
 
       char *e;
-      e = memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
+      e = (char *) memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
       if (e == NULL)
         {
-          e = memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
+          e = (char *) memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
           if (e == NULL)
-            e = memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
+            e = (char *) memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
         }
 
@@ -485 +482 @@
                                    sizeof (struct ar_hdr));
       if (namelen)
-        memcpy (ared->filename, hdr.ar_name, namelen);
+        memcpy (ared->filename, hdr.ar_name, (size_t) namelen);
       ared->filename[namelen] = '\0';
     }
@@ -611 +608 @@
   struct artdata *tdata_hold;
   char armag[SARMAG + 1];
-
-  tdata_hold = abfd->tdata.aout_ar_data;
-
-  if (bfd_read ((PTR) armag, 1, SARMAG, abfd) != SARMAG)
+  bfd_size_type amt;
+
+  if (bfd_bread ((PTR) armag, (bfd_size_type) SARMAG, abfd) != SARMAG)
     {
       if (bfd_get_error () != bfd_error_system_call)
@@ -630 +626 @@
 #endif
 
-  /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
-     involves a cast, we can't do it as the left operand of assignment.  */
-  abfd->tdata.aout_ar_data = ((struct artdata *)
-                              bfd_zalloc (abfd, sizeof (struct artdata)));
-
+  tdata_hold = bfd_ardata (abfd);
+
+  amt = sizeof (struct artdata);
+  bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
   if (bfd_ardata (abfd) == NULL)
-    return NULL;
+    {
+      bfd_ardata (abfd) = tdata_hold;
+      return NULL;
+    }
 
   bfd_ardata (abfd)->first_file_filepos = SARMAG;
@@ -645 +643 @@
   bfd_ardata (abfd)->tdata = NULL;
 
-  if (!BFD_SEND (abfd, _bfd_slurp_armap, (abfd)))
-    {
-      bfd_release (abfd, bfd_ardata (abfd));
-      abfd->tdata.aout_ar_data = tdata_hold;
+  if (!BFD_SEND (abfd, _bfd_slurp_armap, (abfd))
+      || !BFD_SEND (abfd, _bfd_slurp_extended_name_table, (abfd)))
+    {
       if (bfd_get_error () != bfd_error_system_call)
         bfd_set_error (bfd_error_wrong_format);
-      return NULL;
-    }
-
-  if (!BFD_SEND (abfd, _bfd_slurp_extended_name_table, (abfd)))
-    {
       bfd_release (abfd, bfd_ardata (abfd));
-      abfd->tdata.aout_ar_data = tdata_hold;
-      if (bfd_get_error () != bfd_error_system_call)
-        bfd_set_error (bfd_error_wrong_format);
+      bfd_ardata (abfd) = tdata_hold;
       return NULL;
     }
@@ -681 +671 @@
       if (first != NULL)
         {
-          boolean fail;
-
-          first->target_defaulted = false;
-          fail = false;
+          bfd_boolean fail;
+
+          first->target_defaulted = FALSE;
+          fail = FALSE;
           if (bfd_check_format (first, bfd_object)
               && first->xvec != abfd->xvec)
             {
+#if 0
+              /* We ought to close `first' here, but we can't, because
+                 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_release (abfd, bfd_ardata (abfd));
-              abfd->tdata.aout_ar_data = tdata_hold;
-              bfd_set_error (bfd_error_wrong_format);
+#endif
+              bfd_set_error (bfd_error_wrong_object_format);
+              bfd_ardata (abfd) = tdata_hold;
               return NULL;
             }
-
-          /* We ought to close first here, but we can't, because we
-             have no way to remove it from the archive cache.  FIXME.  */
+          /* And we ought to close `first' here too.  */
         }
     }
@@ -706 +700 @@
    support 64 bit archives presently; so far as I know, none actually
    exist.  Supporting them would require changing these constants, and
-   changing some bfd_h_get_32 to bfd_h_get_64.  */
+   changing some H_GET_32 to H_GET_64.  */
 
 /* The size of an external symdef structure.  */
@@ -720 +714 @@
 #define BSD_STRING_COUNT_SIZE 4
 
-/* Returns false on error, true otherwise */
-
-static boolean
+/* Returns FALSE on error, TRUE otherwise */
+
+static bfd_boolean
 do_slurp_bsd_armap (abfd)
      bfd *abfd;
@@ -731 +725 @@
   struct artdata *ardata = bfd_ardata (abfd);
   char *stringbase;
-  unsigned int parsed_size;
+  bfd_size_type parsed_size, amt;
   carsym *set;
 
   mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
   if (mapdata == NULL)
-    return false;
+    return FALSE;
   parsed_size = mapdata->parsed_size;
   bfd_release (abfd, (PTR) mapdata);    /* Don't need it any more.  */
@@ -742 +736 @@
   raw_armap = (bfd_byte *) bfd_zalloc (abfd, parsed_size);
   if (raw_armap == (bfd_byte *) NULL)
-    return false;
-
-  if (bfd_read ((PTR) raw_armap, 1, parsed_size, abfd) != parsed_size)
+    return FALSE;
+
+  if (bfd_bread ((PTR) raw_armap, parsed_size, abfd) != parsed_size)
     {
       if (bfd_get_error () != bfd_error_system_call)
@@ -750 +744 @@
     byebye:
       bfd_release (abfd, (PTR) raw_armap);
-      return false;
-    }
-
-  ardata->symdef_count = bfd_h_get_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE;
+      return FALSE;
+    }
+
+  ardata->symdef_count = H_GET_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE;
 
   if (ardata->symdef_count * BSD_SYMDEF_SIZE >
@@ -768 +762 @@
                 + ardata->symdef_count * BSD_SYMDEF_SIZE
                 + BSD_STRING_COUNT_SIZE);
-  ardata->symdefs = (carsym *) bfd_alloc (abfd,
-                                          (ardata->symdef_count
-                                           * sizeof (carsym)));
+  amt = (bfd_size_type) ardata->symdef_count * sizeof (carsym);
+  ardata->symdefs = (carsym *) bfd_alloc (abfd, amt);
   if (!ardata->symdefs)
-    return false;
+    return FALSE;
 
   for (counter = 0, set = ardata->symdefs;
@@ -778 +771 @@
        counter++, set++, rbase += BSD_SYMDEF_SIZE)
     {
-      set->name = bfd_h_get_32 (abfd, rbase) + stringbase;
-      set->file_offset = bfd_h_get_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
+      set->name = H_GET_32 (abfd, rbase) + stringbase;
+      set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
     }
 
@@ -788 +781 @@
      we are done using the strings from it.  For now, it seems
      to be allocated on an objalloc anyway...  */
-  bfd_has_map (abfd) = true;
-  return true;
-}
-
-/* Returns false on error, true otherwise.  */
-
-static boolean
+  bfd_has_map (abfd) = TRUE;
+  return TRUE;
+}
+
+/* Returns FALSE on error, TRUE otherwise.  */
+
+static bfd_boolean
 do_slurp_coff_armap (abfd)
      bfd *abfd;
@@ -802 +795 @@
   struct artdata *ardata = bfd_ardata (abfd);
   char *stringbase;
-  unsigned int stringsize;
+  bfd_size_type stringsize;
   unsigned int parsed_size;
   carsym *carsyms;
-  unsigned int nsymz;           /* Number of symbols in armap.  */
+  bfd_size_type nsymz;          /* Number of symbols in armap.  */
   bfd_vma (*swap) PARAMS ((const bfd_byte *));
   char int_buf[sizeof (long)];
-  unsigned int carsym_size, ptrsize, i;
+  bfd_size_type carsym_size, ptrsize;
+  unsigned int i;
 
   mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
   if (mapdata == NULL)
-    return false;
+    return FALSE;
   parsed_size = mapdata->parsed_size;
   bfd_release (abfd, (PTR) mapdata);    /* Don't need it any more.  */
 
-  if (bfd_read ((PTR) int_buf, 1, 4, abfd) != 4)
+  if (bfd_bread ((PTR) int_buf, (bfd_size_type) 4, abfd) != 4)
     {
       if (bfd_get_error () != bfd_error_system_call)
         bfd_set_error (bfd_error_malformed_archive);
-      return false;
+      return FALSE;
     }
   /* It seems that all numeric information in a coff archive is always
@@ -853 +847 @@
   ardata->symdefs = (carsym *) bfd_zalloc (abfd, carsym_size + stringsize + 1);
   if (ardata->symdefs == NULL)
-    return false;
+    return FALSE;
   carsyms = ardata->symdefs;
   stringbase = ((char *) ardata->symdefs) + carsym_size;
@@ -861 +855 @@
   if (raw_armap == NULL)
     goto release_symdefs;
-  if (bfd_read ((PTR) raw_armap, 1, ptrsize, abfd) != ptrsize
-      || bfd_read ((PTR) stringbase, 1, stringsize, abfd) != stringsize)
+  if (bfd_bread ((PTR) raw_armap, ptrsize, abfd) != ptrsize
+      || (bfd_bread ((PTR) stringbase, stringsize, abfd) != stringsize))
     {
       if (bfd_get_error () != bfd_error_system_call)
@@ -885 +879 @@
   ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
 
-  bfd_has_map (abfd) = true;
+  bfd_has_map (abfd) = TRUE;
   bfd_release (abfd, (PTR) raw_armap);
 
@@ -892 +886 @@
     struct areltdata *tmp;
 
-    bfd_seek (abfd,   ardata->first_file_filepos, SEEK_SET);
+    bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET);
     tmp = (struct areltdata *) _bfd_read_ar_hdr (abfd);
     if (tmp != NULL)
@@ -900 +894 @@
           {
             ardata->first_file_filepos +=
-              (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~1;
+              (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1;
           }
         bfd_release (abfd, tmp);
@@ -906 +900 @@
   }
 
-  return true;
+  return TRUE;
 
 release_raw_armap:
@@ -912 +906 @@
 release_symdefs:
   bfd_release (abfd, (PTR) (ardata)->symdefs);
-  return false;
+  return FALSE;
 }
 
 /* This routine can handle either coff-style or bsd-style armaps.
-   Returns false on error, true otherwise */
-
-boolean
+   Returns FALSE on error, TRUE otherwise */
+
+bfd_boolean
 bfd_slurp_armap (abfd)
      bfd *abfd;
 {
   char nextname[17];
-  int i = bfd_read ((PTR) nextname, 1, 16, abfd);
+  int i = bfd_bread ((PTR) nextname, (bfd_size_type) 16, abfd);
 
   if (i == 0)
-    return true;
+    return TRUE;
   if (i != 16)
-    return false;
-
-  if (bfd_seek (abfd, (file_ptr) - 16, SEEK_CUR) != 0)
-    return false;
+    return FALSE;
+
+  if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
+    return FALSE;
 
   if (!strncmp (nextname, "__.SYMDEF       ", 16)
@@ -940 +934 @@
   else if (!strncmp (nextname, "/SYM64/         ", 16))
     {
-      /* Irix 6 archive--must be recognized by code in elf64-mips.c.  */
+      /* 64bit ELF (Irix 6) archive.  */
+#ifdef BFD64
+      return bfd_elf64_archive_slurp_armap (abfd);
+#else
       bfd_set_error (bfd_error_wrong_format);
-      return false;
-    }
-
-  bfd_has_map (abfd) = false;
-  return true;
-}
-
-
-/* Returns false on error, true otherwise */
+      return FALSE;
+#endif
+    }
+
+  bfd_has_map (abfd) = FALSE;
+  return TRUE;
+}
+
+
+/* Returns FALSE on error, TRUE otherwise */
 /* flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
    header is in a slightly different order and the map name is '/'.
@@ -957 +955 @@
 #define HPUX_SYMDEF_COUNT_SIZE 2
 
-boolean
+bfd_boolean
 bfd_slurp_bsd_armap_f2 (abfd)
      bfd *abfd;
@@ -968 +966 @@
   char *stringbase;
   unsigned int stringsize;
+  bfd_size_type amt;
   carsym *set;
-  int i = bfd_read ((PTR) nextname, 1, 16, abfd);
+  int i = bfd_bread ((PTR) nextname, (bfd_size_type) 16, abfd);
 
   if (i == 0)
-    return true;
+    return TRUE;
   if (i != 16)
-    return false;
+    return FALSE;
 
   /* The archive has at least 16 bytes in it.  */
-  if (bfd_seek (abfd, -16L, SEEK_CUR) != 0)
-    return false;
+  if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
+    return FALSE;
 
   if (!strncmp (nextname, "__.SYMDEF       ", 16)
@@ -986 +985 @@
   if (strncmp (nextname, "/               ", 16))
     {
-      bfd_has_map (abfd) = false;
-      return true;
+      bfd_has_map (abfd) = FALSE;
+      return TRUE;
     }
 
   mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
   if (mapdata == NULL)
-    return false;
-
-  raw_armap = (bfd_byte *) bfd_zalloc (abfd, mapdata->parsed_size);
+    return FALSE;
+
+  amt = mapdata->parsed_size;
+  raw_armap = (bfd_byte *) bfd_zalloc (abfd, amt);
   if (raw_armap == NULL)
     {
     byebye:
       bfd_release (abfd, (PTR) mapdata);
-      return false;
-    }
-
-  if (bfd_read ((PTR) raw_armap, 1, mapdata->parsed_size, abfd) !=
-      mapdata->parsed_size)
+      return FALSE;
+    }
+
+  if (bfd_bread ((PTR) raw_armap, amt, abfd) != amt)
     {
       if (bfd_get_error () != bfd_error_system_call)
@@ -1012 +1011 @@
     }
 
-  ardata->symdef_count = bfd_h_get_16 (abfd, (PTR) raw_armap);
+  ardata->symdef_count = H_GET_16 (abfd, (PTR) raw_armap);
 
   if (ardata->symdef_count * BSD_SYMDEF_SIZE
@@ -1024 +1023 @@
   ardata->cache = 0;
 
-  stringsize = bfd_h_get_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE);
+  stringsize = H_GET_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE);
   /* Skip sym count and string sz.  */
   stringbase = ((char *) raw_armap
@@ -1030 +1029 @@
                 + BSD_STRING_COUNT_SIZE);
   rbase = (bfd_byte *) stringbase + stringsize;
-  ardata->symdefs = (carsym *) bfd_alloc (abfd,
-                                          (ardata->symdef_count
-                                           * BSD_SYMDEF_SIZE));
+  amt = (bfd_size_type) ardata->symdef_count * BSD_SYMDEF_SIZE;
+  ardata->symdefs = (carsym *) bfd_alloc (abfd, amt);
   if (!ardata->symdefs)
-    return false;
+    return FALSE;
 
   for (counter = 0, set = ardata->symdefs;
@@ -1040 +1038 @@
        counter++, set++, rbase += BSD_SYMDEF_SIZE)
     {
-      set->name = bfd_h_get_32 (abfd, rbase) + stringbase;
-      set->file_offset = bfd_h_get_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
+      set->name = H_GET_32 (abfd, rbase) + stringbase;
+      set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
     }
 
@@ -1050 +1048 @@
      we are done using the strings from it.  For now, it seems
      to be allocated on an objalloc anyway...  */
-  bfd_has_map (abfd) = true;
-  return true;
+  bfd_has_map (abfd) = TRUE;
+  return TRUE;
 }
 
@@ -1065 +1063 @@
   extended the format by using the prefix // for the special element.  */
 
-/* Returns false on error, true otherwise.  */
-
-boolean
+/* Returns FALSE on error, TRUE otherwise.  */
+
+bfd_boolean
 _bfd_slurp_extended_name_table (abfd)
      bfd *abfd;
@@ -1073 +1071 @@
   char nextname[17];
   struct areltdata *namedata;
+  bfd_size_type amt;
 
   /* FIXME:  Formatting sucks here, and in case of failure of BFD_READ,
-     we probably don't want to return true.  */
+     we probably don't want to return TRUE.  */
   bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET);
-  if (bfd_read ((PTR) nextname, 1, 16, abfd) == 16)
-    {
-      if (bfd_seek (abfd, (file_ptr) - 16, SEEK_CUR) != 0)
-        return false;
+  if (bfd_bread ((PTR) nextname, (bfd_size_type) 16, abfd) == 16)
+    {
+      if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
+        return FALSE;
 
       if (strncmp (nextname, "ARFILENAMES/    ", 16) != 0 &&
@@ -1086 +1085 @@
         {
           bfd_ardata (abfd)->extended_names = NULL;
-          return true;
+          return TRUE;
         }
 
       namedata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
       if (namedata == NULL)
-        return false;
-
-      bfd_ardata (abfd)->extended_names =
-        bfd_zalloc (abfd, namedata->parsed_size);
+        return FALSE;
+
+      amt = namedata->parsed_size;
+      bfd_ardata (abfd)->extended_names = bfd_zalloc (abfd, amt);
       if (bfd_ardata (abfd)->extended_names == NULL)
         {
         byebye:
           bfd_release (abfd, (PTR) namedata);
-          return false;
+          return FALSE;
         }
 
-      if (bfd_read ((PTR) bfd_ardata (abfd)->extended_names, 1,
-                    namedata->parsed_size, abfd) != namedata->parsed_size)
+      if (bfd_bread ((PTR) bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
         {
           if (bfd_get_error () != bfd_error_system_call)
@@ -1140 +1138 @@
 #endif
     }
-  return true;
+  return TRUE;
 }
 
@@ -1153 +1151 @@
      const char *file;
 {
-  CONST char *first;
-  CONST char *last;
+  const char *first;
+  const char *last;
   char *copy;
 
@@ -1172 +1170 @@
     }
 
-  copy = (char *) bfd_alloc (abfd, last - first + 1);
+  copy = (char *) bfd_alloc (abfd, (bfd_size_type) (last - first + 1));
   if (copy == NULL)
     return NULL;
@@ -1210 +1208 @@
 /* Build a BFD style extended name table.  */
 
-boolean
+bfd_boolean
 _bfd_archive_bsd_construct_extended_name_table (abfd, tabloc, tablen, name)
      bfd *abfd;
@@ -1218 +1216 @@
 {
   *name = "ARFILENAMES/";
-  return _bfd_construct_extended_name_table (abfd, false, tabloc, tablen);
+  return _bfd_construct_extended_name_table (abfd, FALSE, tabloc, tablen);
 }
 
 /* Build an SVR4 style extended name table.  */
 
-boolean
+bfd_boolean
 _bfd_archive_coff_construct_extended_name_table (abfd, tabloc, tablen, name)
      bfd *abfd;
@@ -1231 +1229 @@
 {
   *name = "//";
-  return _bfd_construct_extended_name_table (abfd, true, tabloc, tablen);
+  return _bfd_construct_extended_name_table (abfd, TRUE, tabloc, tablen);
 }
 
@@ -1238 +1236 @@
    table, and in tablen the length of the table.  If it makes an entry
    it clobbers the filename so that the element may be written without
-   further massage.  Returns true if it ran successfully, false if
+   further massage.  Returns TRUE if it ran successfully, FALSE if
    something went wrong.  A successful return may still involve a
    zero-length tablen!  */
 
-boolean
+bfd_boolean
 _bfd_construct_extended_name_table (abfd, trailing_slash, tabloc, tablen)
      bfd *abfd;
-     boolean trailing_slash;
+     bfd_boolean trailing_slash;
      char **tabloc;
      bfd_size_type *tablen;
 {
   unsigned int maxname = abfd->xvec->ar_max_namelen;
-  unsigned int total_namelen = 0;
+  bfd_size_type total_namelen = 0;
   bfd *current;
   char *strptr;
@@ -1264 +1262 @@
       normal = normalize (current, current->filename);
       if (normal == NULL)
-        return false;
+        return FALSE;
 
       thislen = strlen (normal);
@@ -1300 +1298 @@
 
   if (total_namelen == 0)
-    return true;
+    return TRUE;
 
   *tabloc = bfd_zalloc (abfd, total_namelen);
   if (*tabloc == NULL)
-    return false;
+    return FALSE;
 
   *tablen = total_namelen;
@@ -1317 +1315 @@
       normal = normalize (current, current->filename);
       if (normal == NULL)
-        return false;
+        return FALSE;
 
       thislen = strlen (normal);
@@ -1352 +1350 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -1399 +1397 @@
   struct ar_hdr *hdr;
   char *temp, *temp1;
+  bfd_size_type amt;
 
   if (member && (member->flags & BFD_IN_MEMORY) != 0)
@@ -1416 +1415 @@
     }
 
-  ared = (struct areltdata *) bfd_zalloc (abfd, sizeof (struct ar_hdr) +
-                                          sizeof (struct areltdata));
+  amt = sizeof (struct ar_hdr) + sizeof (struct areltdata);
+  ared = (struct areltdata *) bfd_zalloc (abfd, amt);
   if (ared == NULL)
     return NULL;
@@ -1469 +1468 @@
    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
+  PARAMS ((bfd *, const char *));
 
 struct ar_hdr *
@@ -1544 +1544 @@
 bfd_dont_truncate_arname (abfd, pathname, arhdr)
      bfd *abfd;
-     CONST char *pathname;
+     const char *pathname;
      char *arhdr;
 {
@@ -1584 +1584 @@
 bfd_bsd_truncate_arname (abfd, pathname, arhdr)
      bfd *abfd;
-     CONST char *pathname;
+     const char *pathname;
      char *arhdr;
 {
   struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
-  int length;
-  CONST char *filename = strrchr (pathname, '/');
-  int maxlen = ar_maxnamelen (abfd);
+  size_t length;
+  const char *filename = strrchr (pathname, '/');
+  size_t maxlen = ar_maxnamelen (abfd);
 
 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
@@ -1635 +1635 @@
 bfd_gnu_truncate_arname (abfd, pathname, arhdr)
      bfd *abfd;
-     CONST char *pathname;
+     const char *pathname;
      char *arhdr;
 {
   struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
-  int length;
-  CONST char *filename = strrchr (pathname, '/');
-  int maxlen = ar_maxnamelen (abfd);
+  size_t length;
+  const char *filename = strrchr (pathname, '/');
+  size_t maxlen = ar_maxnamelen (abfd);
 
 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
@@ -1681 +1681 @@
 /* The BFD is open for write and has its format set to bfd_archive.  */
 
-boolean
+bfd_boolean
 _bfd_write_archive_contents (arch)
      bfd *arch;
@@ -1689 +1689 @@
   bfd_size_type elength = 0;
   const char *ename = NULL;
-  boolean makemap = bfd_has_map (arch);
-  boolean hasobjects = false;   /* If no .o's, don't bother to make a map.  */
+  bfd_boolean makemap = bfd_has_map (arch);
+  /* If no .o's, don't bother to make a map.  */
+  bfd_boolean hasobjects = FALSE;
   bfd_size_type wrote;
   unsigned int i;
@@ -1708 +1709 @@
         {
           bfd_set_error (bfd_error_invalid_operation);
-          return false;
+          return FALSE;
         }
       if (!current->arelt_data)
@@ -1715 +1716 @@
             (PTR) bfd_ar_hdr_from_filesystem (arch, current->filename, current);
           if (!current->arelt_data)
-            return false;
+            return FALSE;
 
           /* Put in the file name.  */
@@ -1730 +1731 @@
 #endif
             )
-            hasobjects = true;
+            hasobjects = TRUE;
         }
     }
@@ -1736 +1737 @@
   if (!BFD_SEND (arch, _bfd_construct_extended_name_table,
                  (arch, &etable, &elength, &ename)))
-    return false;
+    return FALSE;
 
   if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0)
-    return false;
+    return FALSE;
 #ifdef GNU960
-  wrote = bfd_write (BFD_GNU960_ARMAG (arch), 1, SARMAG, arch);
+  wrote = bfd_bwrite (BFD_GNU960_ARMAG (arch), (bfd_size_type) SARMAG, arch);
 #else
-  wrote = bfd_write (ARMAG, 1, SARMAG, arch);
+  wrote = bfd_bwrite (ARMAG, (bfd_size_type) SARMAG, arch);
 #endif
   if (wrote != SARMAG)
-    return false;
+    return FALSE;
 
   if (makemap && hasobjects)
     {
-      if (_bfd_compute_and_write_armap (arch, elength) != true)
-        return false;
+      if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength))
+        return FALSE;
     }
 
@@ -1762 +1763 @@
       /* Round size up to even number in archive header.  */
       sprintf (&(hdr.ar_size[0]), "%-10d",
-               (int) ((elength + 1) & ~1));
+               (int) ((elength + 1) & ~(bfd_size_type) 1));
       strncpy (hdr.ar_fmag, ARFMAG, 2);
       for (i = 0; i < sizeof (struct ar_hdr); i++)
         if (((char *) (&hdr))[i] == '\0')
           (((char *) (&hdr))[i]) = ' ';
-      if ((bfd_write ((char *) &hdr, 1, sizeof (struct ar_hdr), arch)
+      if ((bfd_bwrite ((PTR) &hdr, (bfd_size_type) sizeof (struct ar_hdr), arch)
            != sizeof (struct ar_hdr))
-          || bfd_write (etable, 1, elength, arch) != elength)
-        return false;
+          || bfd_bwrite (etable, elength, arch) != elength)
+        return FALSE;
       if ((elength % 2) == 1)
         {
-          if (bfd_write ("\012", 1, 1, arch) != 1)
-            return false;
+          if (bfd_bwrite ("\012", (bfd_size_type) 1, arch) != 1)
+            return FALSE;
         }
     }
@@ -1785 +1786 @@
 
       /* Write ar header.  */
-      if (bfd_write ((char *) hdr, 1, sizeof (*hdr), arch) != sizeof (*hdr))
-        return false;
+      if (bfd_bwrite ((PTR) hdr, (bfd_size_type) sizeof (*hdr), arch)
+          != sizeof (*hdr))
+        return FALSE;
       if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
-        return false;
+        return FALSE;
       while (remaining)
         {
@@ -1795 +1797 @@
             amt = remaining;
           errno = 0;
-          if (bfd_read (buffer, amt, 1, current) != amt)
+          if (bfd_bread (buffer, (bfd_size_type) amt, current) != amt)
             {
               if (bfd_get_error () != bfd_error_system_call)
                 bfd_set_error (bfd_error_malformed_archive);
-              return false;
+              return FALSE;
             }
-          if (bfd_write (buffer, amt, 1, arch) != amt)
-            return false;
+          if (bfd_bwrite (buffer, (bfd_size_type) amt, arch) != amt)
+            return FALSE;
           remaining -= amt;
         }
       if ((arelt_size (current) % 2) == 1)
         {
-          if (bfd_write ("\012", 1, 1, arch) != 1)
-            return false;
+          if (bfd_bwrite ("\012", (bfd_size_type) 1, arch) != 1)
+            return FALSE;
         }
     }
@@ -1831 +1833 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -1837 +1839 @@
 /* Note that the namidx for the first symbol is 0.  */
 
-boolean
+bfd_boolean
 _bfd_compute_and_write_armap (arch, elength)
      bfd *arch;
@@ -1846 +1848 @@
   file_ptr elt_no = 0;
   struct orl *map = NULL;
-  int orl_max = 1024;           /* fine initial default */
-  int orl_count = 0;
+  unsigned int orl_max = 1024;          /* fine initial default */
+  unsigned int orl_count = 0;
   int stridx = 0;               /* string index */
   asymbol **syms = NULL;
   long syms_max = 0;
-  boolean ret;
+  bfd_boolean ret;
+  bfd_size_type amt;
 
   /* Dunno if this is the best place for this info...  */
@@ -1858 +1861 @@
   elength += elength % 2;
 
-  map = (struct orl *) bfd_malloc (orl_max * sizeof (struct orl));
+  amt = (bfd_size_type) orl_max * sizeof (struct orl);
+  map = (struct orl *) bfd_malloc (amt);
   if (map == NULL)
     goto error_return;
@@ -1864 +1868 @@
   /* We put the symbol names on the arch objalloc, and then discard
      them when done.  */
-  first_name = bfd_alloc (arch, 1);
+  first_name = bfd_alloc (arch, (bfd_size_type) 1);
   if (first_name == NULL)
     goto error_return;
@@ -1878 +1882 @@
        current = current->next, elt_no++)
     {
-      if ((bfd_check_format (current, bfd_object) == true)
-          && ((bfd_get_file_flags (current) & HAS_SYMS)))
+      if (bfd_check_format (current, bfd_object)
+          && (bfd_get_file_flags (current) & HAS_SYMS) != 0)
         {
           long storage;
@@ -1896 +1900 @@
                     free (syms);
                   syms_max = storage;
-                  syms = (asymbol **) bfd_malloc ((size_t) syms_max);
+                  syms = (asymbol **) bfd_malloc ((bfd_size_type) syms_max);
                   if (syms == NULL)
                     goto error_return;
@@ -1920 +1924 @@
                       && ! bfd_is_und_section (sec))
                     {
-                      size_t namelen;
+                      bfd_size_type namelen;
                       struct orl *new_map;
 
@@ -1927 +1931 @@
                         {
                           orl_max *= 2;
-                          new_map =
-                            ((struct orl *)
-                             bfd_realloc (map, orl_max * sizeof (struct orl)));
+                          amt = (bfd_size_type) orl_max * sizeof (struct orl);
+                          new_map = (struct orl *) bfd_realloc (map, amt);
                           if (new_map == (struct orl *) NULL)
                             goto error_return;
@@ -1937 +1940 @@
 
                       namelen = strlen (syms[src_count]->name);
-                      map[orl_count].name = ((char **)
-                                             bfd_alloc (arch,
-                                                        sizeof (char *)));
+                      amt = sizeof (char *);
+                      map[orl_count].name = (char **) bfd_alloc (arch, amt);
                       if (map[orl_count].name == NULL)
                         goto error_return;
@@ -1946 +1948 @@
                         goto error_return;
                       strcpy (*(map[orl_count].name), syms[src_count]->name);
-                      (map[orl_count]).pos = (file_ptr) current;
-                      (map[orl_count]).namidx = stridx;
+                      map[orl_count].u.abfd = current;
+                      map[orl_count].namidx = stridx;
 
                       stridx += namelen + 1;
@@ -1983 +1985 @@
     bfd_release (arch, first_name);
 
-  return false;
-}
-
-boolean
+  return FALSE;
+}
+
+bfd_boolean
 bsd_write_armap (arch, elength, map, orl_count, stridx)
      bfd *arch;
@@ -2025 +2027 @@
     if (((char *) (&hdr))[i] == '\0')
       (((char *) (&hdr))[i]) = ' ';
-  if (bfd_write ((char *) &hdr, 1, sizeof (struct ar_hdr), arch)
+  if (bfd_bwrite ((PTR) &hdr, (bfd_size_type) sizeof (struct ar_hdr), arch)
       != sizeof (struct ar_hdr))
-    return false;
-  bfd_h_put_32 (arch, (bfd_vma) ranlibsize, temp);
-  if (bfd_write (temp, 1, sizeof (temp), arch) != sizeof (temp))
-    return false;
+    return FALSE;
+  H_PUT_32 (arch, ranlibsize, temp);
+  if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), arch) != sizeof (temp))
+    return FALSE;
 
   for (count = 0; count < orl_count; count++)
@@ -2036 +2038 @@
       bfd_byte buf[BSD_SYMDEF_SIZE];
 
-      if (((bfd *) (map[count]).pos) != last_elt)
+      if (map[count].u.abfd != last_elt)
         {
           do
@@ -2044 +2046 @@
               current = current->next;
             }
-          while (current != (bfd *) (map[count]).pos);
+          while (current != map[count].u.abfd);
         }                       /* if new archive element */
 
       last_elt = current;
-      bfd_h_put_32 (arch, map[count].namidx, buf);
-      bfd_h_put_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE);
-      if (bfd_write (buf, BSD_SYMDEF_SIZE, 1, arch) != BSD_SYMDEF_SIZE)
-        return false;
+      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)
+          != BSD_SYMDEF_SIZE)
+        return FALSE;
     }
 
   /* Now write the strings themselves.  */
-  bfd_h_put_32 (arch, stringsize, temp);
-  if (bfd_write (temp, 1, sizeof (temp), arch) != sizeof (temp))
-    return false;
+  H_PUT_32 (arch, stringsize, temp);
+  if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), arch) != sizeof (temp))
+    return FALSE;
   for (count = 0; count < orl_count; count++)
     {
       size_t len = strlen (*map[count].name) + 1;
 
-      if (bfd_write (*map[count].name, 1, len, arch) != len)
-        return false;
+      if (bfd_bwrite (*map[count].name, (bfd_size_type) len, arch) != len)
+        return FALSE;
     }
 
@@ -2070 +2073 @@
   if (padit)
     {
-      if (bfd_write ("", 1, 1, arch) != 1)
-        return false;
-    }
-
-  return true;
+      if (bfd_bwrite ("", (bfd_size_type) 1, arch) != 1)
+        return FALSE;
+    }
+
+  return TRUE;
 }
 
@@ -2080 +2083 @@
    file, so the linker will accept it.
 
-   Return true if the timestamp was OK, or an unusual problem happened.
-   Return false if we updated the timestamp.  */
-
-boolean
+   Return TRUE if the timestamp was OK, or an unusual problem happened.
+   Return FALSE if we updated the timestamp.  */
+
+bfd_boolean
 _bfd_archive_bsd_update_armap_timestamp (arch)
      bfd *arch;
@@ -2096 +2099 @@
   if (bfd_stat (arch, &archstat) == -1)
     {
-      perror (_("Reading archive file mod timestamp"));
+      bfd_perror (_("Reading archive file mod timestamp"));
 
       /* Can't read mod time for some reason.  */
-      return true;
+      return TRUE;
     }
   if (archstat.st_mtime <= bfd_ardata (arch)->armap_timestamp)
     /* OK by the linker's rules.  */
-    return true;
+    return TRUE;
 
   /* Update the timestamp.  */
@@ -2119 +2122 @@
                                       + offsetof (struct ar_hdr, ar_date[0]));
   if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0
-      || (bfd_write (hdr.ar_date, sizeof (hdr.ar_date), 1, arch)
+      || (bfd_bwrite (hdr.ar_date, (bfd_size_type) sizeof (hdr.ar_date), arch)
           != sizeof (hdr.ar_date)))
     {
-      /* FIXME: bfd can't call perror.  */
-      perror (_("Writing updated armap timestamp"));
+      bfd_perror (_("Writing updated armap timestamp"));
 
       /* Some error while writing.  */
-      return true;
+      return TRUE;
     }
 
   /* We updated the timestamp successfully.  */
-  return false;
+  return FALSE;
 }
 
@@ -2148 +2150 @@
 */
 
-boolean
+bfd_boolean
 coff_write_armap (arch, elength, map, symbol_count, stridx)
      bfd *arch;
@@ -2157 +2159 @@
 {
   /* The size of the ranlib is the number of exported symbols in the
-     archive * the number of bytes in a int, + an int for the count.  */
+     archive * the number of bytes in an int, + an int for the count.  */
   unsigned int ranlibsize = (symbol_count * 4) + 4;
   unsigned int stringsize = stridx;
   unsigned int mapsize = stringsize + ranlibsize;
-  file_ptr archive_member_file_ptr;
+  unsigned int archive_member_file_ptr;
   bfd *current = arch->archive_head;
   unsigned int count;
@@ -2193 +2195 @@
   /* Write the ar header for this item and the number of symbols.  */
 
-  if (bfd_write ((PTR) &hdr, 1, sizeof (struct ar_hdr), arch)
+  if (bfd_bwrite ((PTR) &hdr, (bfd_size_type) sizeof (struct ar_hdr), arch)
       != sizeof (struct ar_hdr))
-    return false;
-
-  bfd_write_bigendian_4byte_int (arch, symbol_count);
+    return FALSE;
+
+  if (!bfd_write_bigendian_4byte_int (arch, symbol_count))
+    return FALSE;
 
   /* Two passes, first write the file offsets for each symbol -
@@ -2212 +2215 @@
          out the object file's address in the archive.  */
 
-      while (count < symbol_count && ((bfd *) (map[count]).pos) == current)
+      while (count < symbol_count && map[count].u.abfd == current)
         {
-          bfd_write_bigendian_4byte_int (arch, archive_member_file_ptr);
+          if (!bfd_write_bigendian_4byte_int (arch, archive_member_file_ptr))
+            return FALSE;
           count++;
         }
@@ -2230 +2234 @@
       size_t len = strlen (*map[count].name) + 1;
 
-      if (bfd_write (*map[count].name, 1, len, arch) != len)
-        return false;
+      if (bfd_bwrite (*map[count].name, (bfd_size_type) len, arch) != len)
+        return FALSE;
     }
 
@@ -2238 +2242 @@
   if (padit)
     {
-      if (bfd_write ("", 1, 1, arch) != 1)
-        return false;
-    }
-
-  return true;
-}
+      if (bfd_bwrite ("", (bfd_size_type) 1, arch) != 1)
+        return FALSE;
+    }
+
+  return TRUE;
+}