bfd: use https for bugzilla

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

diff --git a/bfd/archive.c b/bfd/archive.c
index eb5f5ec0cfa80ddd199ae2baf00bafaf968b30e3..2f3a1d4194c21fc0b0b6a8813bc00e145b3e6bcf 100644 (file)
--- a/bfd/archive.c
+++ b/bfd/archive.c
@@ -1,7 +1,5 @@
 /* BFD back-end for archive files (libraries).
 /* BFD back-end for archive files (libraries).

-   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
-   2012  Free Software Foundation, Inc.
+   Copyright (C) 1990-2021 Free Software Foundation, Inc.

    Written by Cygnus Support.  Mostly Gumby Henkel-Wallace's fault.
 
    This file is part of BFD, the Binary File Descriptor library.
    Written by Cygnus Support.  Mostly Gumby Henkel-Wallace's fault.
 
    This file is part of BFD, the Binary File Descriptor library.


@@ -42,11 +40,17 @@ DESCRIPTION
        have to read the entire archive if you don't want
        to!  Read it until you find what you want.
 
        have to read the entire archive if you don't want
        to!  Read it until you find what you want.
 

+       A BFD returned by <<bfd_openr_next_archived_file>> can be
+       closed manually with <<bfd_close>>.  If you do not close it,
+       then a second iteration through the members of an archive may
+       return the same BFD.  If you close the archive BFD, then all
+       the member BFDs will automatically be closed as well.
+

        Archive contents of output BFDs are chained through the
        Archive contents of output BFDs are chained through the

-       <<next>> pointer in a BFD.  The first one is findable through
-       the <<archive_head>> slot of the archive.  Set it with
-       <<bfd_set_archive_head>> (q.v.).  A given BFD may be in only one
-       open output archive at a time.
+       <<archive_next>> pointer in a BFD.  The first one is findable
+       through the <<archive_head>> slot of the archive.  Set it with
+       <<bfd_set_archive_head>> (q.v.).  A given BFD may be in only
+       one open output archive at a time.

 
        As expected, the BFD archive code is more general than the
        archive code of any given environment.  BFD archives may
 
        As expected, the BFD archive code is more general than the
        archive code of any given environment.  BFD archives may


@@ -136,6 +140,7 @@ SUBSECTION
 #include "safe-ctype.h"
 #include "hashtab.h"
 #include "filenames.h"
 #include "safe-ctype.h"
 #include "hashtab.h"
 #include "filenames.h"

+#include "bfdlink.h"

 
 #ifndef errno
 extern int errno;
 
 #ifndef errno
 extern int errno;


@@ -147,7 +152,8 @@ extern int errno;
    it's generally short enough to search linearly.
    Note that the pointers here point to the front of the ar_hdr, not
    to the front of the contents!  */
    it's generally short enough to search linearly.
    Note that the pointers here point to the front of the ar_hdr, not
    to the front of the contents!  */

-struct ar_cache {
+struct ar_cache
+{

   file_ptr ptr;
   bfd *arbfd;
 };
   file_ptr ptr;
   bfd *arbfd;
 };


@@ -166,8 +172,9 @@ struct ar_cache {
 void
 _bfd_ar_spacepad (char *p, size_t n, const char *fmt, long val)
 {
 void
 _bfd_ar_spacepad (char *p, size_t n, const char *fmt, long val)
 {

-  static char buf[20];
+  char buf[20];

   size_t len;
   size_t len;

+

   snprintf (buf, sizeof (buf), fmt, val);
   len = strlen (buf);
   if (len < n)
   snprintf (buf, sizeof (buf), fmt, val);
   len = strlen (buf);
   if (len < n)


@@ -179,10 +186,10 @@ _bfd_ar_spacepad (char *p, size_t n, const char *fmt, long val)
     memcpy (p, buf, n);
 }
 
     memcpy (p, buf, n);
 }
 

-bfd_boolean
+bool

 _bfd_ar_sizepad (char *p, size_t n, bfd_size_type size)
 {
 _bfd_ar_sizepad (char *p, size_t n, bfd_size_type size)
 {

-  static char buf[21];
+  char buf[21];

   size_t len;
 
   snprintf (buf, sizeof (buf), "%-10" BFD_VMA_FMT "u", size);
   size_t len;
 
   snprintf (buf, sizeof (buf), "%-10" BFD_VMA_FMT "u", size);


@@ -190,7 +197,7 @@ _bfd_ar_sizepad (char *p, size_t n, bfd_size_type size)
   if (len > n)
     {
       bfd_set_error (bfd_error_file_too_big);
   if (len > n)
     {
       bfd_set_error (bfd_error_file_too_big);

-      return FALSE;
+      return false;

     }
   if (len < n)
     {
     }
   if (len < n)
     {


@@ -199,17 +206,17 @@ _bfd_ar_sizepad (char *p, size_t n, bfd_size_type size)
     }
   else
     memcpy (p, buf, n);
     }
   else
     memcpy (p, buf, n);

-  return TRUE;
+  return true;

 }
 \f
 }
 \f

-bfd_boolean
+bool

 _bfd_generic_mkarchive (bfd *abfd)
 {
 _bfd_generic_mkarchive (bfd *abfd)
 {

-  bfd_size_type amt = sizeof (struct artdata);
+  size_t amt = sizeof (struct artdata);

 
   abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc (abfd, amt);
   if (bfd_ardata (abfd) == NULL)
 
   abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc (abfd, amt);
   if (bfd_ardata (abfd) == NULL)

-    return FALSE;
+    return false;

 
   /* Already cleared by bfd_zalloc above.
      bfd_ardata (abfd)->cache = NULL;
 
   /* Already cleared by bfd_zalloc above.
      bfd_ardata (abfd)->cache = NULL;


@@ -219,7 +226,7 @@ _bfd_generic_mkarchive (bfd *abfd)
      bfd_ardata (abfd)->extended_names_size = 0;
      bfd_ardata (abfd)->tdata = NULL;  */
 
      bfd_ardata (abfd)->extended_names_size = 0;
      bfd_ardata (abfd)->tdata = NULL;  */
 

-  return TRUE;
+  return true;

 }
 
 /*
 }
 
 /*


@@ -277,18 +284,18 @@ FUNCTION
        bfd_set_archive_head
 
 SYNOPSIS
        bfd_set_archive_head
 
 SYNOPSIS

-       bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);
+       bool bfd_set_archive_head (bfd *output, bfd *new_head);

 
 DESCRIPTION
        Set the head of the chain of
        BFDs contained in the archive @var{output} to @var{new_head}.
 */
 
 
 DESCRIPTION
        Set the head of the chain of
        BFDs contained in the archive @var{output} to @var{new_head}.
 */
 

-bfd_boolean
+bool

 bfd_set_archive_head (bfd *output_archive, bfd *new_head)
 {
   output_archive->archive_head = new_head;
 bfd_set_archive_head (bfd *output_archive, bfd *new_head)
 {
   output_archive->archive_head = new_head;

-  return TRUE;
+  return true;

 }
 
 bfd *
 }
 
 bfd *


@@ -296,6 +303,7 @@ _bfd_look_for_bfd_in_cache (bfd *arch_bfd, file_ptr filepos)
 {
   htab_t hash_table = bfd_ardata (arch_bfd)->cache;
   struct ar_cache m;
 {
   htab_t hash_table = bfd_ardata (arch_bfd)->cache;
   struct ar_cache m;

+

   m.ptr = filepos;
 
   if (hash_table)
   m.ptr = filepos;
 
   if (hash_table)


@@ -303,15 +311,19 @@ _bfd_look_for_bfd_in_cache (bfd *arch_bfd, file_ptr filepos)
       struct ar_cache *entry = (struct ar_cache *) htab_find (hash_table, &m);
       if (!entry)
        return NULL;
       struct ar_cache *entry = (struct ar_cache *) htab_find (hash_table, &m);
       if (!entry)
        return NULL;

-      else
-       return entry->arbfd;
+
+      /* Unfortunately this flag is set after checking that we have
+        an archive, and checking for an archive means one element has
+        sneaked into the cache.  */
+      entry->arbfd->no_export = arch_bfd->no_export;
+      return entry->arbfd;

     }
   else
     return NULL;
 }
 
 static hashval_t
     }
   else
     return NULL;
 }
 
 static hashval_t

-hash_file_ptr (const PTR p)
+hash_file_ptr (const void * p)

 {
   return (hashval_t) (((struct ar_cache *) p)->ptr);
 }
 {
   return (hashval_t) (((struct ar_cache *) p)->ptr);
 }


@@ -319,7 +331,7 @@ hash_file_ptr (const PTR p)
 /* Returns non-zero if P1 and P2 are equal.  */
 
 static int
 /* Returns non-zero if P1 and P2 are equal.  */
 
 static int

-eq_file_ptr (const PTR p1, const PTR p2)
+eq_file_ptr (const void * p1, const void * p2)

 {
   struct ar_cache *arc1 = (struct ar_cache *) p1;
   struct ar_cache *arc2 = (struct ar_cache *) p2;
 {
   struct ar_cache *arc1 = (struct ar_cache *) p1;
   struct ar_cache *arc2 = (struct ar_cache *) p2;


@@ -337,7 +349,7 @@ _bfd_calloc_wrapper (size_t a, size_t b)
 
 /* Kind of stupid to call cons for each one, but we don't do too many.  */
 
 
 /* Kind of stupid to call cons for each one, but we don't do too many.  */
 

-bfd_boolean
+bool

 _bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt)
 {
   struct ar_cache *cache;
 _bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt)
 {
   struct ar_cache *cache;


@@ -349,7 +361,7 @@ _bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt)
       hash_table = htab_create_alloc (16, hash_file_ptr, eq_file_ptr,
                                      NULL, _bfd_calloc_wrapper, free);
       if (hash_table == NULL)
       hash_table = htab_create_alloc (16, hash_file_ptr, eq_file_ptr,
                                      NULL, _bfd_calloc_wrapper, free);
       if (hash_table == NULL)

-       return FALSE;
+       return false;

       bfd_ardata (arch_bfd)->cache = hash_table;
     }
 
       bfd_ardata (arch_bfd)->cache = hash_table;
     }
 


@@ -359,26 +371,52 @@ _bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt)
   cache->arbfd = new_elt;
   *htab_find_slot (hash_table, (const void *) cache, INSERT) = cache;
 
   cache->arbfd = new_elt;
   *htab_find_slot (hash_table, (const void *) cache, INSERT) = cache;
 

-  return TRUE;
+  /* Provide a means of accessing this from child.  */
+  arch_eltdata (new_elt)->parent_cache = hash_table;
+  arch_eltdata (new_elt)->key = filepos;
+
+  return true;

 }
 \f
 static bfd *
 }
 \f
 static bfd *

-_bfd_find_nested_archive (bfd *arch_bfd, const char *filename)
+open_nested_file (const char *filename, bfd *archive)

 {
 {

-  bfd *abfd;

   const char *target;
   const char *target;

+  bfd *n_bfd;
+
+  target = NULL;
+  if (!archive->target_defaulted)
+    target = archive->xvec->name;
+  n_bfd = bfd_openr (filename, target);
+  if (n_bfd != NULL)
+    {
+      n_bfd->lto_output = archive->lto_output;
+      n_bfd->no_export = archive->no_export;
+      n_bfd->my_archive = archive;
+    }
+  return n_bfd;
+}
+
+static bfd *
+find_nested_archive (const char *filename, bfd *arch_bfd)
+{
+  bfd *abfd;
+
+  /* PR 15140: Don't allow a nested archive pointing to itself.  */
+  if (filename_cmp (filename, bfd_get_filename (arch_bfd)) == 0)
+    {
+      bfd_set_error (bfd_error_malformed_archive);
+      return NULL;
+    }

 
   for (abfd = arch_bfd->nested_archives;
        abfd != NULL;
        abfd = abfd->archive_next)
     {
 
   for (abfd = arch_bfd->nested_archives;
        abfd != NULL;
        abfd = abfd->archive_next)
     {

-      if (filename_cmp (filename, abfd->filename) == 0)
-        return abfd;
+      if (filename_cmp (filename, bfd_get_filename (abfd)) == 0)
+       return abfd;

     }
     }

-  target = NULL;
-  if (!arch_bfd->target_defaulted)
-    target = arch_bfd->xvec->name;
-  abfd = bfd_openr (filename, target);
+  abfd = open_nested_file (filename, arch_bfd);

   if (abfd)
     {
       abfd->archive_next = arch_bfd->nested_archives;
   if (abfd)
     {
       abfd->archive_next = arch_bfd->nested_archives;


@@ -413,10 +451,10 @@ get_extended_arelt_filename (bfd *arch, const char *name, file_ptr *originp)
       file_ptr origin = strtol (endp + 1, NULL, 10);
 
       if (errno != 0)
       file_ptr origin = strtol (endp + 1, NULL, 10);
 
       if (errno != 0)

-        {
-          bfd_set_error (bfd_error_malformed_archive);
-          return NULL;
-        }
+       {
+         bfd_set_error (bfd_error_malformed_archive);
+         return NULL;
+       }

       *originp = origin;
     }
   else
       *originp = origin;
     }
   else


@@ -450,11 +488,14 @@ _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
   bfd_size_type parsed_size;
   struct areltdata *ared;
   char *filename = NULL;
   bfd_size_type parsed_size;
   struct areltdata *ared;
   char *filename = NULL;

+  ufile_ptr filesize;

   bfd_size_type namelen = 0;
   bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
   char *allocptr = 0;
   file_ptr origin = 0;
   unsigned int extra_size = 0;
   bfd_size_type namelen = 0;
   bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
   char *allocptr = 0;
   file_ptr origin = 0;
   unsigned int extra_size = 0;

+  char fmag_save;
+  int scan;

 
   if (bfd_bread (hdrp, sizeof (struct ar_hdr), abfd) != sizeof (struct ar_hdr))
     {
 
   if (bfd_bread (hdrp, sizeof (struct ar_hdr), abfd) != sizeof (struct ar_hdr))
     {


@@ -471,8 +512,11 @@ _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
     }
 
   errno = 0;
     }
 
   errno = 0;

+  fmag_save = hdr.ar_fmag[0];

   hdr.ar_fmag[0] = 0;
   hdr.ar_fmag[0] = 0;

-  if (sscanf (hdr.ar_size, "%" BFD_VMA_FMT "u", &parsed_size) != 1)
+  scan = sscanf (hdr.ar_size, "%" BFD_VMA_FMT "u", &parsed_size);
+  hdr.ar_fmag[0] = fmag_save;
+  if (scan != 1)

     {
       bfd_set_error (bfd_error_malformed_archive);
       return NULL;
     {
       bfd_set_error (bfd_error_malformed_archive);
       return NULL;


@@ -495,11 +539,19 @@ _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
     {
       /* BSD-4.4 extended name */
       namelen = atoi (&hdr.ar_name[3]);
     {
       /* BSD-4.4 extended name */
       namelen = atoi (&hdr.ar_name[3]);

+      filesize = bfd_get_file_size (abfd);
+      if (namelen > parsed_size
+         || namelen > -allocsize - 2
+         || (filesize != 0 && namelen > filesize))
+       {
+         bfd_set_error (bfd_error_malformed_archive);
+         return NULL;
+       }

       allocsize += namelen + 1;
       parsed_size -= namelen;
       extra_size = namelen;
 
       allocsize += namelen + 1;
       parsed_size -= namelen;
       extra_size = namelen;
 

-      allocptr = (char *) bfd_zalloc (abfd, allocsize);
+      allocptr = (char *) bfd_malloc (allocsize);

       if (allocptr == NULL)
        return NULL;
       filename = (allocptr
       if (allocptr == NULL)
        return NULL;
       filename = (allocptr


@@ -507,6 +559,7 @@ _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
                  + sizeof (struct ar_hdr));
       if (bfd_bread (filename, namelen, abfd) != namelen)
        {
                  + sizeof (struct ar_hdr));
       if (bfd_bread (filename, namelen, abfd) != namelen)
        {

+         free (allocptr);

          if (bfd_get_error () != bfd_error_system_call)
            bfd_set_error (bfd_error_no_more_archived_files);
          return NULL;
          if (bfd_get_error () != bfd_error_system_call)
            bfd_set_error (bfd_error_no_more_archived_files);
          return NULL;


@@ -542,13 +595,13 @@ _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
 
   if (!allocptr)
     {
 
   if (!allocptr)
     {

-      allocptr = (char *) bfd_zalloc (abfd, allocsize);
+      allocptr = (char *) bfd_malloc (allocsize);

       if (allocptr == NULL)
        return NULL;
     }
 
       if (allocptr == NULL)
        return NULL;
     }
 

+  memset (allocptr, 0, sizeof (struct areltdata));

   ared = (struct areltdata *) allocptr;
   ared = (struct areltdata *) allocptr;

-

   ared->arch_header = allocptr + sizeof (struct areltdata);
   memcpy (ared->arch_header, &hdr, sizeof (struct ar_hdr));
   ared->parsed_size = parsed_size;
   ared->arch_header = allocptr + sizeof (struct areltdata);
   memcpy (ared->arch_header, &hdr, sizeof (struct ar_hdr));
   ared->parsed_size = parsed_size;


@@ -575,7 +628,7 @@ _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
 char *
 _bfd_append_relative_path (bfd *arch, char *elt_name)
 {
 char *
 _bfd_append_relative_path (bfd *arch, char *elt_name)
 {

-  const char *arch_name = arch->filename;
+  const char *arch_name = bfd_get_filename (arch);

   const char *base_name = lbasename (arch_name);
   size_t prefix_len;
   char *filename;
   const char *base_name = lbasename (arch_name);
   size_t prefix_len;
   char *filename;


@@ -601,12 +654,12 @@ bfd *
 _bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos)
 {
   struct areltdata *new_areldata;
 _bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos)
 {
   struct areltdata *new_areldata;

-  bfd *n_nfd;
+  bfd *n_bfd;

   char *filename;
 
   char *filename;
 

-  n_nfd = _bfd_look_for_bfd_in_cache (archive, filepos);
-  if (n_nfd)
-    return n_nfd;
+  n_bfd = _bfd_look_for_bfd_in_cache (archive, filepos);
+  if (n_bfd)
+    return n_bfd;

 
   if (0 > bfd_seek (archive, filepos, SEEK_SET))
     return NULL;
 
   if (0 > bfd_seek (archive, filepos, SEEK_SET))
     return NULL;


@@ -618,78 +671,94 @@ _bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos)
 
   if (bfd_is_thin_archive (archive))
     {
 
   if (bfd_is_thin_archive (archive))
     {

-      const char *target;
-

       /* This is a proxy entry for an external file.  */
       if (! IS_ABSOLUTE_PATH (filename))
       /* This is a proxy entry for an external file.  */
       if (! IS_ABSOLUTE_PATH (filename))

-        {
-          filename = _bfd_append_relative_path (archive, filename);
-          if (filename == NULL)
-            return NULL;
-        }
+       {
+         filename = _bfd_append_relative_path (archive, filename);
+         if (filename == NULL)
+           {
+             free (new_areldata);
+             return NULL;
+           }
+       }

 
       if (new_areldata->origin > 0)
 
       if (new_areldata->origin > 0)

-        {
-          /* This proxy entry refers to an element of a nested archive.
-             Locate the member of that archive and return a bfd for it.  */
-          bfd *ext_arch = _bfd_find_nested_archive (archive, filename);
-
-          if (ext_arch == NULL
-              || ! bfd_check_format (ext_arch, bfd_archive))
-            {
-              bfd_release (archive, new_areldata);
-              return NULL;
-            }
-          n_nfd = _bfd_get_elt_at_filepos (ext_arch, new_areldata->origin);
-          if (n_nfd == NULL)
-            {
-              bfd_release (archive, new_areldata);
-              return NULL;
-            }
-          n_nfd->proxy_origin = bfd_tell (archive);
-          return n_nfd;
-        }
+       {
+         /* This proxy entry refers to an element of a nested archive.
+            Locate the member of that archive and return a bfd for it.  */
+         bfd *ext_arch = find_nested_archive (filename, archive);
+
+         if (ext_arch == NULL
+             || ! bfd_check_format (ext_arch, bfd_archive))
+           {
+             free (new_areldata);
+             return NULL;
+           }
+         n_bfd = _bfd_get_elt_at_filepos (ext_arch, new_areldata->origin);
+         if (n_bfd == NULL)
+           {
+             free (new_areldata);
+             return NULL;
+           }
+         n_bfd->proxy_origin = bfd_tell (archive);
+
+         /* Copy BFD_COMPRESS, BFD_DECOMPRESS and BFD_COMPRESS_GABI
+            flags.  */
+         n_bfd->flags |= archive->flags & (BFD_COMPRESS
+                                           | BFD_DECOMPRESS
+                                           | BFD_COMPRESS_GABI);
+
+         return n_bfd;
+       }
+

       /* It's not an element of a nested archive;
       /* It's not an element of a nested archive;

-         open the external file as a bfd.  */
-      target = NULL;
-      if (!archive->target_defaulted)
-       target = archive->xvec->name;
-      n_nfd = bfd_openr (filename, target);
-      if (n_nfd == NULL)
+        open the external file as a bfd.  */
+      n_bfd = open_nested_file (filename, archive);
+      if (n_bfd == NULL)

        bfd_set_error (bfd_error_malformed_archive);
     }
   else
     {
        bfd_set_error (bfd_error_malformed_archive);
     }
   else
     {

-      n_nfd = _bfd_create_empty_archive_element_shell (archive);
+      n_bfd = _bfd_create_empty_archive_element_shell (archive);

     }
 
     }
 

-  if (n_nfd == NULL)
+  if (n_bfd == NULL)

     {
     {

-      bfd_release (archive, new_areldata);
+      free (new_areldata);

       return NULL;
     }
 
       return NULL;
     }
 

-  n_nfd->proxy_origin = bfd_tell (archive);
+  n_bfd->proxy_origin = bfd_tell (archive);

 
   if (bfd_is_thin_archive (archive))
     {
 
   if (bfd_is_thin_archive (archive))
     {

-      n_nfd->origin = 0;
+      n_bfd->origin = 0;

     }
   else
     {
     }
   else
     {

-      n_nfd->origin = n_nfd->proxy_origin;
-      n_nfd->filename = filename;
+      n_bfd->origin = n_bfd->proxy_origin;
+      if (!bfd_set_filename (n_bfd, filename))
+       goto out;

     }
 
     }
 

-  n_nfd->arelt_data = new_areldata;
+  n_bfd->arelt_data = new_areldata;
+
+  /* Copy BFD_COMPRESS, BFD_DECOMPRESS and BFD_COMPRESS_GABI flags.  */
+  n_bfd->flags |= archive->flags & (BFD_COMPRESS
+                                   | BFD_DECOMPRESS
+                                   | BFD_COMPRESS_GABI);

 
 

-  /* Copy BFD_COMPRESS and BFD_DECOMPRESS flags.  */
-  n_nfd->flags |= archive->flags & (BFD_COMPRESS | BFD_DECOMPRESS);
+  /* Copy is_linker_input.  */
+  n_bfd->is_linker_input = archive->is_linker_input;

 
 

-  if (_bfd_add_bfd_to_archive_cache (archive, filepos, n_nfd))
-    return n_nfd;
+  if (archive->no_element_cache
+      || _bfd_add_bfd_to_archive_cache (archive, filepos, n_bfd))
+    return n_bfd;

 
 

-  bfd_release (archive, new_areldata);
+ out:
+  free (new_areldata);
+  n_bfd->arelt_data = NULL;
+  bfd_close (n_bfd);

   return NULL;
 }
 
   return NULL;
 }
 


@@ -705,6 +774,13 @@ _bfd_generic_get_elt_at_index (bfd *abfd, symindex sym_index)
   return _bfd_get_elt_at_filepos (abfd, entry->file_offset);
 }
 
   return _bfd_get_elt_at_filepos (abfd, entry->file_offset);
 }
 

+bfd *
+_bfd_noarchive_get_elt_at_index (bfd *abfd,
+                                symindex sym_index ATTRIBUTE_UNUSED)
+{
+  return (bfd *) _bfd_ptr_bfd_null_error (abfd);
+}
+

 /*
 FUNCTION
        bfd_openr_next_archived_file
 /*
 FUNCTION
        bfd_openr_next_archived_file


@@ -715,10 +791,11 @@ SYNOPSIS
 DESCRIPTION
        Provided a BFD, @var{archive}, containing an archive and NULL, open
        an input BFD on the first contained element and returns that.
 DESCRIPTION
        Provided a BFD, @var{archive}, containing an archive and NULL, open
        an input BFD on the first contained element and returns that.

-       Subsequent calls should pass
-       the archive and the previous return value to return a created
-       BFD to the next contained element. NULL is returned when there
-       are no more.
+       Subsequent calls should pass the archive and the previous return
+       value to return a created BFD to the next contained element.  NULL
+       is returned when there are no more.
+       Note - if you want to process the bfd returned by this call be
+       sure to call bfd_check_format() on it first.

 */
 
 bfd *
 */
 
 bfd *


@@ -738,32 +815,47 @@ bfd_openr_next_archived_file (bfd *archive, bfd *last_file)
 bfd *
 bfd_generic_openr_next_archived_file (bfd *archive, bfd *last_file)
 {
 bfd *
 bfd_generic_openr_next_archived_file (bfd *archive, bfd *last_file)
 {

-  file_ptr filestart;
+  ufile_ptr filestart;

 
   if (!last_file)
     filestart = bfd_ardata (archive)->first_file_filepos;
   else
     {
 
   if (!last_file)
     filestart = bfd_ardata (archive)->first_file_filepos;
   else
     {

-      bfd_size_type size = arelt_size (last_file);
-

       filestart = last_file->proxy_origin;
       if (! bfd_is_thin_archive (archive))
       filestart = last_file->proxy_origin;
       if (! bfd_is_thin_archive (archive))

-        filestart += size;
-      /* Pad to an even boundary...
-        Note that last_file->origin can be odd in the case of
-        BSD-4.4-style element with a long odd size.  */
-      filestart += filestart % 2;
+       {
+         bfd_size_type size = arelt_size (last_file);
+
+         filestart += size;
+         /* Pad to an even boundary...
+            Note that last_file->origin can be odd in the case of
+            BSD-4.4-style element with a long odd size.  */
+         filestart += filestart % 2;
+         if (filestart < last_file->proxy_origin)
+           {
+             /* Prevent looping.  See PR19256.  */
+             bfd_set_error (bfd_error_malformed_archive);
+             return NULL;
+           }
+       }

     }
 
   return _bfd_get_elt_at_filepos (archive, filestart);
 }
 
     }
 
   return _bfd_get_elt_at_filepos (archive, filestart);
 }
 

-const bfd_target *
+bfd *
+_bfd_noarchive_openr_next_archived_file (bfd *archive,
+                                        bfd *last_file ATTRIBUTE_UNUSED)
+{
+  return (bfd *) _bfd_ptr_bfd_null_error (archive);
+}
+
+bfd_cleanup

 bfd_generic_archive_p (bfd *abfd)
 {
   struct artdata *tdata_hold;
   char armag[SARMAG + 1];
 bfd_generic_archive_p (bfd *abfd)
 {
   struct artdata *tdata_hold;
   char armag[SARMAG + 1];

-  bfd_size_type amt;
+  size_t amt;

 
   if (bfd_bread (armag, SARMAG, abfd) != SARMAG)
     {
 
   if (bfd_bread (armag, SARMAG, abfd) != SARMAG)
     {


@@ -772,12 +864,14 @@ bfd_generic_archive_p (bfd *abfd)
       return NULL;
     }
 
       return NULL;
     }
 

-  bfd_is_thin_archive (abfd) = (strncmp (armag, ARMAGT, SARMAG) == 0);
+  bfd_set_thin_archive (abfd, strncmp (armag, ARMAGT, SARMAG) == 0);

 
   if (strncmp (armag, ARMAG, SARMAG) != 0
 
   if (strncmp (armag, ARMAG, SARMAG) != 0

-      && strncmp (armag, ARMAGB, SARMAG) != 0

       && ! bfd_is_thin_archive (abfd))
       && ! bfd_is_thin_archive (abfd))

-    return NULL;
+    {
+      bfd_set_error (bfd_error_wrong_format);
+      return NULL;
+    }

 
   tdata_hold = bfd_ardata (abfd);
 
 
   tdata_hold = bfd_ardata (abfd);
 


@@ -811,6 +905,7 @@ bfd_generic_archive_p (bfd *abfd)
   if (abfd->target_defaulted && bfd_has_map (abfd))
     {
       bfd *first;
   if (abfd->target_defaulted && bfd_has_map (abfd))
     {
       bfd *first;

+      unsigned int save;

 
       /* This archive has a map, so we may presume that the contents
         are object files.  Make sure that if the first file in the
 
       /* This archive has a map, so we may presume that the contents
         are object files.  Make sure that if the first file in the


@@ -823,22 +918,21 @@ bfd_generic_archive_p (bfd *abfd)
         normal archive, regardless of the format of the object files.
         We do accept an empty archive.  */
 
         normal archive, regardless of the format of the object files.
         We do accept an empty archive.  */
 

+      save = abfd->no_element_cache;
+      abfd->no_element_cache = 1;

       first = bfd_openr_next_archived_file (abfd, NULL);
       first = bfd_openr_next_archived_file (abfd, NULL);

+      abfd->no_element_cache = save;

       if (first != NULL)
        {
       if (first != NULL)
        {

-         first->target_defaulted = FALSE;
+         first->target_defaulted = false;

          if (bfd_check_format (first, bfd_object)
              && first->xvec != abfd->xvec)
          if (bfd_check_format (first, bfd_object)
              && first->xvec != abfd->xvec)

-           {
-             bfd_set_error (bfd_error_wrong_object_format);
-             bfd_ardata (abfd) = tdata_hold;
-             return NULL;
-           }
-         /* And we ought to close `first' here too.  */
+           bfd_set_error (bfd_error_wrong_object_format);
+         bfd_close (first);

        }
     }
 
        }
     }
 

-  return abfd->xvec;
+  return _bfd_no_cleanup;

 }
 
 /* Some constants for a 32 bit BSD archive structure.  We do not
 }
 
 /* Some constants for a 32 bit BSD archive structure.  We do not


@@ -861,61 +955,70 @@ bfd_generic_archive_p (bfd *abfd)
 /* Read a BSD-style archive symbol table.  Returns FALSE on error,
    TRUE otherwise.  */
 
 /* Read a BSD-style archive symbol table.  Returns FALSE on error,
    TRUE otherwise.  */
 

-static bfd_boolean
+static bool

 do_slurp_bsd_armap (bfd *abfd)
 {
   struct areltdata *mapdata;
 do_slurp_bsd_armap (bfd *abfd)
 {
   struct areltdata *mapdata;

-  unsigned int counter;
+  size_t counter;

   bfd_byte *raw_armap, *rbase;
   struct artdata *ardata = bfd_ardata (abfd);
   char *stringbase;
   bfd_byte *raw_armap, *rbase;
   struct artdata *ardata = bfd_ardata (abfd);
   char *stringbase;

-  bfd_size_type parsed_size, amt;
+  bfd_size_type parsed_size;
+  size_t amt, string_size;

   carsym *set;
 
   mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
   if (mapdata == NULL)
   carsym *set;
 
   mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
   if (mapdata == NULL)

-    return FALSE;
+    return false;

   parsed_size = mapdata->parsed_size;
   parsed_size = mapdata->parsed_size;

-  bfd_release (abfd, mapdata); /* Don't need it any more.  */
-
-  raw_armap = (bfd_byte *) bfd_zalloc (abfd, parsed_size);
-  if (raw_armap == NULL)
-    return FALSE;
-
-  if (bfd_bread (raw_armap, parsed_size, abfd) != parsed_size)
+  free (mapdata);
+  /* PR 17512: file: 883ff754.  */
+  /* PR 17512: file: 0458885f.  */
+  if (parsed_size < BSD_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE)

     {
     {

-      if (bfd_get_error () != bfd_error_system_call)
-       bfd_set_error (bfd_error_malformed_archive);
-    byebye:
-      bfd_release (abfd, raw_armap);
-      return FALSE;
+      bfd_set_error (bfd_error_malformed_archive);
+      return false;

     }
 
     }
 

-  ardata->symdef_count = H_GET_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE;
+  raw_armap = (bfd_byte *) _bfd_alloc_and_read (abfd, parsed_size, parsed_size);
+  if (raw_armap == NULL)
+    return false;

 
 

-  if (ardata->symdef_count * BSD_SYMDEF_SIZE >
-      parsed_size - BSD_SYMDEF_COUNT_SIZE)
+  parsed_size -= BSD_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE;
+  amt = H_GET_32 (abfd, raw_armap);
+  if (amt > parsed_size
+      || amt % BSD_SYMDEF_SIZE != 0)

     {
       /* Probably we're using the wrong byte ordering.  */
       bfd_set_error (bfd_error_wrong_format);
     {
       /* Probably we're using the wrong byte ordering.  */
       bfd_set_error (bfd_error_wrong_format);

-      goto byebye;
+      goto release_armap;

     }
 
     }
 

-  ardata->cache = 0;

   rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE;
   rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE;

-  stringbase = ((char *) rbase
-               + ardata->symdef_count * BSD_SYMDEF_SIZE
-               + BSD_STRING_COUNT_SIZE);
-  amt = ardata->symdef_count * sizeof (carsym);
+  stringbase = (char *) rbase + amt + BSD_STRING_COUNT_SIZE;
+  string_size = parsed_size - amt;
+
+  ardata->symdef_count = amt / BSD_SYMDEF_SIZE;
+  if (_bfd_mul_overflow (ardata->symdef_count, sizeof (carsym), &amt))
+    {
+      bfd_set_error (bfd_error_no_memory);
+      goto release_armap;
+    }

   ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt);
   if (!ardata->symdefs)
   ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt);
   if (!ardata->symdefs)

-    return FALSE;
+    goto release_armap;

 
   for (counter = 0, set = ardata->symdefs;
        counter < ardata->symdef_count;
        counter++, set++, rbase += BSD_SYMDEF_SIZE)
     {
 
   for (counter = 0, set = ardata->symdefs;
        counter < ardata->symdef_count;
        counter++, set++, rbase += BSD_SYMDEF_SIZE)
     {

-      set->name = H_GET_32 (abfd, rbase) + stringbase;
+      unsigned nameoff = H_GET_32 (abfd, rbase);
+      if (nameoff >= string_size)
+       {
+         bfd_set_error (bfd_error_malformed_archive);
+         goto release_armap;
+       }
+      set->name = stringbase + nameoff;

       set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
     }
 
       set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
     }
 


@@ -925,301 +1028,191 @@ do_slurp_bsd_armap (bfd *abfd)
   /* FIXME, we should provide some way to free raw_ardata when
      we are done using the strings from it.  For now, it seems
      to be allocated on an objalloc anyway...  */
   /* FIXME, we should provide some way to free raw_ardata when
      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;
+  abfd->has_armap = true;
+  return true;
+
+ release_armap:
+  ardata->symdef_count = 0;
+  ardata->symdefs = NULL;
+  bfd_release (abfd, raw_armap);
+  return false;

 }
 
 /* Read a COFF archive symbol table.  Returns FALSE on error, TRUE
    otherwise.  */
 
 }
 
 /* Read a COFF archive symbol table.  Returns FALSE on error, TRUE
    otherwise.  */
 

-static bfd_boolean
+static bool

 do_slurp_coff_armap (bfd *abfd)
 {
   struct areltdata *mapdata;
   int *raw_armap, *rawptr;
   struct artdata *ardata = bfd_ardata (abfd);
   char *stringbase;
 do_slurp_coff_armap (bfd *abfd)
 {
   struct areltdata *mapdata;
   int *raw_armap, *rawptr;
   struct artdata *ardata = bfd_ardata (abfd);
   char *stringbase;

+  char *stringend;

   bfd_size_type stringsize;
   bfd_size_type parsed_size;
   bfd_size_type stringsize;
   bfd_size_type parsed_size;

+  ufile_ptr filesize;
+  size_t nsymz, carsym_size, ptrsize, i;

   carsym *carsyms;
   carsym *carsyms;

-  bfd_size_type nsymz;         /* Number of symbols in armap.  */

   bfd_vma (*swap) (const void *);
   bfd_vma (*swap) (const void *);

-  char int_buf[sizeof (long)];
-  bfd_size_type carsym_size, ptrsize;
-  unsigned int i;
+  char int_buf[4];
+  struct areltdata *tmp;

 
   mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
   if (mapdata == NULL)
 
   mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
   if (mapdata == NULL)

-    return FALSE;
+    return false;

   parsed_size = mapdata->parsed_size;
   parsed_size = mapdata->parsed_size;

-  bfd_release (abfd, mapdata); /* Don't need it any more.  */
+  free (mapdata);

 
   if (bfd_bread (int_buf, 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);
-      return FALSE;
-    }
+    return false;
+

   /* It seems that all numeric information in a coff archive is always
   /* It seems that all numeric information in a coff archive is always

-     in big endian format, nomatter the host or target.  */
+     in big endian format, no matter the host or target.  */

   swap = bfd_getb32;
   nsymz = bfd_getb32 (int_buf);
   swap = bfd_getb32;
   nsymz = bfd_getb32 (int_buf);

-  stringsize = parsed_size - (4 * nsymz) - 4;

 
 

-  /* ... except that some archive formats are broken, and it may be our
-     fault - the i960 little endian coff sometimes has big and sometimes
-     little, because our tools changed.  Here's a horrible hack to clean
-     up the crap.  */
+  /* The coff armap must be read sequentially.  So we construct a
+     bsd-style one in core all at once, for simplicity.  */

 
 

-  if (stringsize > 0xfffff
-      && bfd_get_arch (abfd) == bfd_arch_i960
-      && bfd_get_flavour (abfd) == bfd_target_coff_flavour)
+  if (_bfd_mul_overflow (nsymz, sizeof (carsym), &carsym_size))

     {
     {

-      /* This looks dangerous, let's do it the other way around.  */
-      nsymz = bfd_getl32 (int_buf);
-      stringsize = parsed_size - (4 * nsymz) - 4;
-      swap = bfd_getl32;
+      bfd_set_error (bfd_error_no_memory);
+      return false;

     }
 
     }
 

-  /* The coff armap must be read sequentially.  So we construct a
-     bsd-style one in core all at once, for simplicity.  */
-
-  if (nsymz > ~ (bfd_size_type) 0 / sizeof (carsym))
-    return FALSE;
+  filesize = bfd_get_file_size (abfd);
+  ptrsize = 4 * nsymz;
+  if ((filesize != 0 && parsed_size > filesize)
+      || parsed_size < 4
+      || parsed_size - 4 < ptrsize)
+    {
+      bfd_set_error (bfd_error_malformed_archive);
+      return false;
+    }

 
 

-  carsym_size = (nsymz * sizeof (carsym));
-  ptrsize = (4 * nsymz);
+  stringsize = parsed_size - ptrsize - 4;

 
   if (carsym_size + stringsize + 1 <= carsym_size)
 
   if (carsym_size + stringsize + 1 <= carsym_size)

-    return FALSE;
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return false;
+    }

 
 

-  ardata->symdefs = (struct carsym *) bfd_zalloc (abfd,
-                                                  carsym_size + stringsize + 1);
+  /* Allocate and read in the raw offsets.  */
+  raw_armap = (int *) _bfd_malloc_and_read (abfd, ptrsize, ptrsize);
+  if (raw_armap == NULL)
+    return false;
+
+  ardata->symdefs = (struct carsym *) bfd_alloc (abfd,
+                                                carsym_size + stringsize + 1);

   if (ardata->symdefs == NULL)
   if (ardata->symdefs == NULL)

-    return FALSE;
+    goto free_armap;

   carsyms = ardata->symdefs;
   stringbase = ((char *) ardata->symdefs) + carsym_size;
 
   carsyms = ardata->symdefs;
   stringbase = ((char *) ardata->symdefs) + carsym_size;
 

-  /* Allocate and read in the raw offsets.  */
-  raw_armap = (int *) bfd_alloc (abfd, ptrsize);
-  if (raw_armap == NULL)
+  if (bfd_bread (stringbase, stringsize, abfd) != stringsize)

     goto release_symdefs;
     goto release_symdefs;

-  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);
-      goto release_raw_armap;
-    }

 
   /* OK, build the carsyms.  */
 
   /* OK, build the carsyms.  */

+  stringend = stringbase + stringsize;
+  *stringend = 0;

   for (i = 0; i < nsymz; i++)
     {
       rawptr = raw_armap + i;
       carsyms->file_offset = swap ((bfd_byte *) rawptr);
       carsyms->name = stringbase;
   for (i = 0; i < nsymz; i++)
     {
       rawptr = raw_armap + i;
       carsyms->file_offset = swap ((bfd_byte *) rawptr);
       carsyms->name = stringbase;

-      stringbase += strlen (stringbase) + 1;
+      stringbase += strlen (stringbase);
+      if (stringbase != stringend)
+       ++stringbase;

       carsyms++;
     }
       carsyms++;
     }

-  *stringbase = 0;

 
   ardata->symdef_count = nsymz;
   ardata->first_file_filepos = bfd_tell (abfd);
   /* Pad to an even boundary if you have to.  */
   ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
 
   ardata->symdef_count = nsymz;
   ardata->first_file_filepos = bfd_tell (abfd);
   /* Pad to an even boundary if you have to.  */
   ardata->first_file_filepos += (ardata->first_file_filepos) % 2;

+  if (bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET) != 0)
+    goto release_symdefs;

 
 

-  bfd_has_map (abfd) = TRUE;
-  bfd_release (abfd, raw_armap);
+  abfd->has_armap = true;
+  free (raw_armap);

 
   /* Check for a second archive header (as used by PE).  */
 
   /* 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);
-    if (tmp != NULL)
-      {
-       if (tmp->arch_header[0] == '/'
-           && tmp->arch_header[1] == ' ')
-         {
-           ardata->first_file_filepos +=
-             (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1;
-         }
-       bfd_release (abfd, tmp);
-      }
-  }
+  tmp = (struct areltdata *) _bfd_read_ar_hdr (abfd);
+  if (tmp != NULL)
+    {
+      if (tmp->arch_header[0] == '/'
+         && tmp->arch_header[1] == ' ')
+       ardata->first_file_filepos
+         += (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1;
+      free (tmp);
+    }

 
 

-  return TRUE;
+  return true;

 
 

-release_raw_armap:
-  bfd_release (abfd, raw_armap);
-release_symdefs:
+ release_symdefs:

   bfd_release (abfd, (ardata)->symdefs);
   bfd_release (abfd, (ardata)->symdefs);

-  return FALSE;
+ free_armap:
+  free (raw_armap);
+  return false;

 }
 
 /* This routine can handle either coff-style or bsd-style armaps
    (archive symbol table).  Returns FALSE on error, TRUE otherwise */
 
 }
 
 /* This routine can handle either coff-style or bsd-style armaps
    (archive symbol table).  Returns FALSE on error, TRUE otherwise */
 

-bfd_boolean
+bool

 bfd_slurp_armap (bfd *abfd)
 {
   char nextname[17];
   int i = bfd_bread (nextname, 16, abfd);
 
   if (i == 0)
 bfd_slurp_armap (bfd *abfd)
 {
   char nextname[17];
   int i = bfd_bread (nextname, 16, abfd);
 
   if (i == 0)

-    return TRUE;
+    return true;

   if (i != 16)
   if (i != 16)

-    return FALSE;
+    return false;

 
   if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
 
   if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)

-    return FALSE;
+    return false;

 
 

-  if (CONST_STRNEQ (nextname, "__.SYMDEF       ")
-      || CONST_STRNEQ (nextname, "__.SYMDEF/      ")) /* Old Linux archives.  */
+  if (startswith (nextname, "__.SYMDEF       ")
+      || startswith (nextname, "__.SYMDEF/      ")) /* Old Linux archives.  */

     return do_slurp_bsd_armap (abfd);
     return do_slurp_bsd_armap (abfd);

-  else if (CONST_STRNEQ (nextname, "/               "))
+  else if (startswith (nextname, "/               "))

     return do_slurp_coff_armap (abfd);
     return do_slurp_coff_armap (abfd);

-  else if (CONST_STRNEQ (nextname, "/SYM64/         "))
+  else if (startswith (nextname, "/SYM64/         "))

     {
     {

-      /* 64bit ELF (Irix 6) archive.  */
+      /* 64bit (Irix 6) archive.  */

 #ifdef BFD64
 #ifdef BFD64

-      extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *);
-      return bfd_elf64_archive_slurp_armap (abfd);
+      return _bfd_archive_64_bit_slurp_armap (abfd);

 #else
       bfd_set_error (bfd_error_wrong_format);
 #else
       bfd_set_error (bfd_error_wrong_format);

-      return FALSE;
+      return false;

 #endif
     }
 #endif
     }

-  else if (CONST_STRNEQ (nextname, "#1/20           "))
+  else if (startswith (nextname, "#1/20           "))

     {
       /* Mach-O has a special name for armap when the map is sorted by name.
     {
       /* Mach-O has a special name for armap when the map is sorted by name.

-         However because this name has a space it is slightly more difficult
-         to check it.  */
+        However because this name has a space it is slightly more difficult
+        to check it.  */

       struct ar_hdr hdr;
       char extname[21];
 
       if (bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
       struct ar_hdr hdr;
       char extname[21];
 
       if (bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))

-        return FALSE;
+       return false;

       /* Read the extended name.  We know its length.  */
       if (bfd_bread (extname, 20, abfd) != 20)
       /* Read the extended name.  We know its length.  */
       if (bfd_bread (extname, 20, abfd) != 20)

-        return FALSE;
+       return false;

       if (bfd_seek (abfd, -(file_ptr) (sizeof (hdr) + 20), SEEK_CUR) != 0)
       if (bfd_seek (abfd, -(file_ptr) (sizeof (hdr) + 20), SEEK_CUR) != 0)

-        return FALSE;
-      if (CONST_STRNEQ (extname, "__.SYMDEF SORTED")
-          || CONST_STRNEQ (extname, "__.SYMDEF"))
-        return do_slurp_bsd_armap (abfd);
-    }
-
-  bfd_has_map (abfd) = FALSE;
-  return TRUE;
-}
-\f
-/* 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 '/'.
-   This flavour is used by hp300hpux.  */
-
-#define HPUX_SYMDEF_COUNT_SIZE 2
-
-bfd_boolean
-bfd_slurp_bsd_armap_f2 (bfd *abfd)
-{
-  struct areltdata *mapdata;
-  char nextname[17];
-  unsigned int counter;
-  bfd_byte *raw_armap, *rbase;
-  struct artdata *ardata = bfd_ardata (abfd);
-  char *stringbase;
-  unsigned int stringsize;
-  unsigned int left;
-  bfd_size_type amt;
-  carsym *set;
-  int i = bfd_bread (nextname, 16, abfd);
-
-  if (i == 0)
-    return TRUE;
-  if (i != 16)
-    return FALSE;
-
-  /* The archive has at least 16 bytes in it.  */
-  if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
-    return FALSE;
-
-  if (CONST_STRNEQ (nextname, "__.SYMDEF       ")
-      || CONST_STRNEQ (nextname, "__.SYMDEF/      ")) /* Old Linux archives.  */
-    return do_slurp_bsd_armap (abfd);
-
-  if (! CONST_STRNEQ (nextname, "/               "))
-    {
-      bfd_has_map (abfd) = FALSE;
-      return TRUE;
-    }
-
-  mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
-  if (mapdata == NULL)
-    return FALSE;
-
-  if (mapdata->parsed_size < HPUX_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE)
-    {
-    wrong_format:
-      bfd_set_error (bfd_error_wrong_format);
-    byebye:
-      bfd_release (abfd, mapdata);
-      return FALSE;
-    }
-  left = mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE - BSD_STRING_COUNT_SIZE;
-
-  amt = mapdata->parsed_size;
-  raw_armap = (bfd_byte *) bfd_zalloc (abfd, amt);
-  if (raw_armap == NULL)
-    goto byebye;
-
-  if (bfd_bread (raw_armap, amt, abfd) != amt)
-    {
-      if (bfd_get_error () != bfd_error_system_call)
-       bfd_set_error (bfd_error_malformed_archive);
-      goto byebye;
-    }
-
-  ardata->symdef_count = H_GET_16 (abfd, raw_armap);
-
-  ardata->cache = 0;
-
-  stringsize = H_GET_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE);
-  if (stringsize > left)
-    goto wrong_format;
-  left -= stringsize;
-
-  /* Skip sym count and string sz.  */
-  stringbase = ((char *) raw_armap
-               + HPUX_SYMDEF_COUNT_SIZE
-               + BSD_STRING_COUNT_SIZE);
-  rbase = (bfd_byte *) stringbase + stringsize;
-  amt = ardata->symdef_count * BSD_SYMDEF_SIZE;
-  if (amt > left)
-    goto wrong_format;
-
-  ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt);
-  if (!ardata->symdefs)
-    return FALSE;
-
-  for (counter = 0, set = ardata->symdefs;
-       counter < ardata->symdef_count;
-       counter++, set++, rbase += BSD_SYMDEF_SIZE)
-    {
-      set->name = H_GET_32 (abfd, rbase) + stringbase;
-      set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
+       return false;
+      extname[20] = 0;
+      if (startswith (extname, "__.SYMDEF SORTED")
+         || startswith (extname, "__.SYMDEF"))
+       return do_slurp_bsd_armap (abfd);

     }
 
     }
 

-  ardata->first_file_filepos = bfd_tell (abfd);
-  /* Pad to an even boundary if you have to.  */
-  ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
-  /* FIXME, we should provide some way to free raw_ardata when
-     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;
+  abfd->has_armap = false;
+  return true;

 }
 \f
 /** Extended name table.
 }
 \f
 /** Extended name table.


@@ -1234,46 +1227,54 @@ bfd_slurp_bsd_armap_f2 (bfd *abfd)
 
 /* Returns FALSE on error, TRUE otherwise.  */
 
 
 /* Returns FALSE on error, TRUE otherwise.  */
 

-bfd_boolean
+bool

 _bfd_slurp_extended_name_table (bfd *abfd)
 {
   char nextname[17];
 _bfd_slurp_extended_name_table (bfd *abfd)
 {
   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.  */
   if (bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET) != 0)
 
   /* FIXME:  Formatting sucks here, and in case of failure of BFD_READ,
      we probably don't want to return TRUE.  */
   if (bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET) != 0)

-    return FALSE;
+    return false;

 
   if (bfd_bread (nextname, 16, abfd) == 16)
     {
 
   if (bfd_bread (nextname, 16, abfd) == 16)
     {

+      struct areltdata *namedata;
+      bfd_size_type amt;
+      ufile_ptr filesize;
+

       if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
       if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)

-       return FALSE;
+       return false;

 
 

-      if (! CONST_STRNEQ (nextname, "ARFILENAMES/    ")
-         && ! CONST_STRNEQ (nextname, "//              "))
+      if (! startswith (nextname, "ARFILENAMES/    ")
+         && ! startswith (nextname, "//              "))

        {
          bfd_ardata (abfd)->extended_names = NULL;
          bfd_ardata (abfd)->extended_names_size = 0;
        {
          bfd_ardata (abfd)->extended_names = NULL;
          bfd_ardata (abfd)->extended_names_size = 0;

-         return TRUE;
+         return true;

        }
 
       namedata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
       if (namedata == NULL)
        }
 
       namedata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
       if (namedata == NULL)

-       return FALSE;
+       return false;

 
 

+      filesize = bfd_get_file_size (abfd);

       amt = namedata->parsed_size;
       amt = namedata->parsed_size;

-      if (amt + 1 == 0)
-        goto byebye;
+      if (amt + 1 == 0 || (filesize != 0 && amt > filesize))
+       {
+         bfd_set_error (bfd_error_malformed_archive);
+         goto byebye;
+       }

 
       bfd_ardata (abfd)->extended_names_size = amt;
 
       bfd_ardata (abfd)->extended_names_size = amt;

-      bfd_ardata (abfd)->extended_names = (char *) bfd_zalloc (abfd, amt + 1);
+      bfd_ardata (abfd)->extended_names = (char *) bfd_alloc (abfd, amt + 1);

       if (bfd_ardata (abfd)->extended_names == NULL)
        {
        byebye:
       if (bfd_ardata (abfd)->extended_names == NULL)
        {
        byebye:

-         bfd_release (abfd, namedata);
-         return FALSE;
+         free (namedata);
+         bfd_ardata (abfd)->extended_names = NULL;
+         bfd_ardata (abfd)->extended_names_size = 0;
+         return false;

        }
 
       if (bfd_bread (bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
        }
 
       if (bfd_bread (bfd_ardata (abfd)->extended_names, amt, abfd) != amt)


@@ -1284,16 +1285,18 @@ _bfd_slurp_extended_name_table (bfd *abfd)
          bfd_ardata (abfd)->extended_names = NULL;
          goto byebye;
        }
          bfd_ardata (abfd)->extended_names = NULL;
          goto byebye;
        }

+      bfd_ardata (abfd)->extended_names[amt] = 0;

 
       /* Since the archive is supposed to be printable if it contains
         text, the entries in the list are newline-padded, not null
         padded. In SVR4-style archives, the names also have a
         trailing '/'.  DOS/NT created archive often have \ in them
 
       /* Since the archive is supposed to be printable if it contains
         text, the entries in the list are newline-padded, not null
         padded. In SVR4-style archives, the names also have a
         trailing '/'.  DOS/NT created archive often have \ in them

-        We'll fix all problems here..  */
+        We'll fix all problems here.  */

       {
       {

-        char *ext_names = bfd_ardata (abfd)->extended_names;
+       char *ext_names = bfd_ardata (abfd)->extended_names;

        char *temp = ext_names;
        char *limit = temp + namedata->parsed_size;
        char *temp = ext_names;
        char *limit = temp + namedata->parsed_size;

+

        for (; temp < limit; ++temp)
          {
            if (*temp == ARFMAG[1])
        for (; temp < limit; ++temp)
          {
            if (*temp == ARFMAG[1])


@@ -1309,10 +1312,9 @@ _bfd_slurp_extended_name_table (bfd *abfd)
       bfd_ardata (abfd)->first_file_filepos +=
        (bfd_ardata (abfd)->first_file_filepos) % 2;
 
       bfd_ardata (abfd)->first_file_filepos +=
        (bfd_ardata (abfd)->first_file_filepos) % 2;
 

-      /* FIXME, we can't release namedata here because it was allocated
-        below extended_names on the objalloc...  */
+      free (namedata);

     }
     }

-  return TRUE;
+  return true;

 }
 
 #ifdef VMS
 }
 
 #ifdef VMS


@@ -1327,6 +1329,9 @@ normalize (bfd *abfd, const char *file)
   const char *last;
   char *copy;
 
   const char *last;
   char *copy;
 

+  if (abfd->flags & BFD_ARCHIVE_FULL_PATH)
+    return file;
+

   first = file + strlen (file) - 1;
   last = first + 1;
 
   first = file + strlen (file) - 1;
   last = first + 1;
 


@@ -1354,8 +1359,10 @@ normalize (bfd *abfd, const char *file)
 
 #else
 static const char *
 
 #else
 static const char *

-normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file)
+normalize (bfd *abfd, const char *file)

 {
 {

+  if (abfd->flags & BFD_ARCHIVE_FULL_PATH)
+    return file;

   return lbasename (file);
 }
 #endif
   return lbasename (file);
 }
 #endif


@@ -1365,23 +1372,23 @@ normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file)
 
      Relative path  Reference path  Result
      -------------  --------------  ------
 
      Relative path  Reference path  Result
      -------------  --------------  ------

-     bar.o          lib.a           bar.o
-     foo/bar.o      lib.a           foo/bar.o
-     bar.o          foo/lib.a       ../bar.o
-     foo/bar.o      baz/lib.a       ../foo/bar.o
-     bar.o          ../lib.a        <parent of current dir>/bar.o
-   ; ../bar.o       ../lib.a        bar.o
-   ; ../bar.o       lib.a           ../bar.o
-     foo/bar.o      ../lib.a        <parent of current dir>/foo/bar.o
-     bar.o          ../../lib.a     <grandparent>/<parent>/bar.o
-     bar.o          foo/baz/lib.a   ../../bar.o
+     bar.o         lib.a           bar.o
+     foo/bar.o     lib.a           foo/bar.o
+     bar.o         foo/lib.a       ../bar.o
+     foo/bar.o     baz/lib.a       ../foo/bar.o
+     bar.o         ../lib.a        <parent of current dir>/bar.o
+   ; ../bar.o      ../lib.a        bar.o
+   ; ../bar.o      lib.a           ../bar.o
+     foo/bar.o     ../lib.a        <parent of current dir>/foo/bar.o
+     bar.o         ../../lib.a     <grandparent>/<parent>/bar.o
+     bar.o         foo/baz/lib.a   ../../bar.o

 
    Note - the semicolons above are there to prevent the BFD chew
    utility from interpreting those lines as prototypes to put into
    the autogenerated bfd.h header...
 
    Note - the string is returned in a static buffer.  */
 
    Note - the semicolons above are there to prevent the BFD chew
    utility from interpreting those lines as prototypes to put into
    the autogenerated bfd.h header...
 
    Note - the string is returned in a static buffer.  */

-   
+

 static const char *
 adjust_relative_path (const char * path, const char * ref_path)
 {
 static const char *
 adjust_relative_path (const char * path, const char * ref_path)
 {


@@ -1404,7 +1411,7 @@ adjust_relative_path (const char * path, const char * ref_path)
 
   rpath = lrealpath (ref_path);
   refp = rpath == NULL ? ref_path : rpath;
 
   rpath = lrealpath (ref_path);
   refp = rpath == NULL ? ref_path : rpath;

- 
+

   /* Remove common leading path elements.  */
   for (;;)
     {
   /* Remove common leading path elements.  */
   for (;;)
     {


@@ -1430,7 +1437,7 @@ adjust_relative_path (const char * path, const char * ref_path)
       {
        /* PR 12710:  If the path element is "../" then instead of
           inserting "../" we need to insert the name of the directory
       {
        /* PR 12710:  If the path element is "../" then instead of
           inserting "../" we need to insert the name of the directory

-          at the current level.  */    
+          at the current level.  */

        if (refp > ref_path + 1
            && refp[-1] == '.'
            && refp[-2] == '.')
        if (refp > ref_path + 1
            && refp[-1] == '.'
            && refp[-2] == '.')


@@ -1441,7 +1448,7 @@ adjust_relative_path (const char * path, const char * ref_path)
 
   /* If the lrealpath calls above succeeded then we should never
      see dir_up and dir_down both being non-zero.  */
 
   /* If the lrealpath calls above succeeded then we should never
      see dir_up and dir_down both being non-zero.  */

-  
+

   len += 3 * dir_up;
 
   if (dir_down)
   len += 3 * dir_up;
 
   if (dir_down)


@@ -1461,8 +1468,7 @@ adjust_relative_path (const char * path, const char * ref_path)
 
   if (len > pathbuf_len)
     {
 
   if (len > pathbuf_len)
     {

-      if (pathbuf != NULL)
-       free (pathbuf);
+      free (pathbuf);

       pathbuf_len = 0;
       pathbuf = (char *) bfd_malloc (len);
       if (pathbuf == NULL)
       pathbuf_len = 0;
       pathbuf = (char *) bfd_malloc (len);
       if (pathbuf == NULL)


@@ -1491,26 +1497,35 @@ adjust_relative_path (const char * path, const char * ref_path)
 
 /* Build a BFD style extended name table.  */
 
 
 /* Build a BFD style extended name table.  */
 

-bfd_boolean
+bool

 _bfd_archive_bsd_construct_extended_name_table (bfd *abfd,
                                                char **tabloc,
                                                bfd_size_type *tablen,
                                                const char **name)
 {
   *name = "ARFILENAMES/";
 _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);
+  return _bfd_construct_extended_name_table (abfd, false, tabloc, tablen);

 }
 
 /* Build an SVR4 style extended name table.  */
 
 }
 
 /* Build an SVR4 style extended name table.  */
 

-bfd_boolean
+bool

 _bfd_archive_coff_construct_extended_name_table (bfd *abfd,
                                                 char **tabloc,
                                                 bfd_size_type *tablen,
                                                 const char **name)
 {
   *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);
+  return _bfd_construct_extended_name_table (abfd, true, tabloc, tablen);
+}
+
+bool
+_bfd_noarchive_construct_extended_name_table (bfd *abfd ATTRIBUTE_UNUSED,
+                                             char **tabloc ATTRIBUTE_UNUSED,
+                                             bfd_size_type *len ATTRIBUTE_UNUSED,
+                                             const char **name ATTRIBUTE_UNUSED)
+{
+  return true;

 }
 
 /* Follows archive_head and produces an extended name table if
 }
 
 /* Follows archive_head and produces an extended name table if


@@ -1521,9 +1536,9 @@ _bfd_archive_coff_construct_extended_name_table (bfd *abfd,
    something went wrong.  A successful return may still involve a
    zero-length tablen!  */
 
    something went wrong.  A successful return may still involve a
    zero-length tablen!  */
 

-bfd_boolean
+bool

 _bfd_construct_extended_name_table (bfd *abfd,
 _bfd_construct_extended_name_table (bfd *abfd,

-                                   bfd_boolean trailing_slash,
+                                   bool trailing_slash,

                                    char **tabloc,
                                    bfd_size_type *tablen)
 {
                                    char **tabloc,
                                    bfd_size_type *tablen)
 {


@@ -1546,44 +1561,44 @@ _bfd_construct_extended_name_table (bfd *abfd,
       unsigned int thislen;
 
       if (bfd_is_thin_archive (abfd))
       unsigned int thislen;
 
       if (bfd_is_thin_archive (abfd))

-        {
-          const char *filename = current->filename;
-
-          /* If the element being added is a member of another archive
-             (i.e., we are flattening), use the containing archive's name.  */
-          if (current->my_archive
-              && ! bfd_is_thin_archive (current->my_archive))
-            filename = current->my_archive->filename;
-
-          /* If the path is the same as the previous path seen,
-             reuse it.  This can happen when flattening a thin
-             archive that contains other archives.  */
-          if (last_filename && filename_cmp (last_filename, filename) == 0)
-            continue;
-
-          last_filename = filename;
-
-          /* If the path is relative, adjust it relative to
-             the containing archive. */
-          if (! IS_ABSOLUTE_PATH (filename)
-              && ! IS_ABSOLUTE_PATH (abfd->filename))
-            normal = adjust_relative_path (filename, abfd->filename);
-          else
-            normal = filename;
-
-          /* In a thin archive, always store the full pathname
-             in the extended name table.  */
-          total_namelen += strlen (normal) + 1;
+       {
+         const char *filename = bfd_get_filename (current);
+
+         /* If the element being added is a member of another archive
+            (i.e., we are flattening), use the containing archive's name.  */
+         if (current->my_archive
+             && ! bfd_is_thin_archive (current->my_archive))
+           filename = bfd_get_filename (current->my_archive);
+
+         /* If the path is the same as the previous path seen,
+            reuse it.  This can happen when flattening a thin
+            archive that contains other archives.  */
+         if (last_filename && filename_cmp (last_filename, filename) == 0)
+           continue;
+
+         last_filename = filename;
+
+         /* If the path is relative, adjust it relative to
+            the containing archive. */
+         if (! IS_ABSOLUTE_PATH (filename)
+             && ! IS_ABSOLUTE_PATH (bfd_get_filename (abfd)))
+           normal = adjust_relative_path (filename, bfd_get_filename (abfd));
+         else
+           normal = filename;
+
+         /* In a thin archive, always store the full pathname
+            in the extended name table.  */
+         total_namelen += strlen (normal) + 1;

          if (trailing_slash)
            /* Leave room for trailing slash.  */
            ++total_namelen;
 
          if (trailing_slash)
            /* Leave room for trailing slash.  */
            ++total_namelen;
 

-          continue;
-        }
+         continue;
+       }

 
 

-      normal = normalize (current, current->filename);
+      normal = normalize (abfd, bfd_get_filename (current));

       if (normal == NULL)
       if (normal == NULL)

-       return FALSE;
+       return false;

 
       thislen = strlen (normal);
 
 
       thislen = strlen (normal);
 


@@ -1609,7 +1624,7 @@ _bfd_construct_extended_name_table (bfd *abfd,
                  && hdr->ar_name[thislen] != ar_padchar (current)))
            {
              /* Must have been using extended format even though it
                  && hdr->ar_name[thislen] != ar_padchar (current)))
            {
              /* Must have been using extended format even though it

-                didn't need to.  Fix it to use normal format.  */
+                didn't need to.  Fix it to use normal format.  */

              memcpy (hdr->ar_name, normal, thislen);
              if (thislen < maxname
                  || (thislen == maxname && thislen < sizeof hdr->ar_name))
              memcpy (hdr->ar_name, normal, thislen);
              if (thislen < maxname
                  || (thislen == maxname && thislen < sizeof hdr->ar_name))


@@ -1619,11 +1634,11 @@ _bfd_construct_extended_name_table (bfd *abfd,
     }
 
   if (total_namelen == 0)
     }
 
   if (total_namelen == 0)

-    return TRUE;
+    return true;

 
 

-  *tabloc = (char *) bfd_zalloc (abfd, total_namelen);
+  *tabloc = (char *) bfd_alloc (abfd, total_namelen);

   if (*tabloc == NULL)
   if (*tabloc == NULL)

-    return FALSE;
+    return false;

 
   *tablen = total_namelen;
   strptr = *tabloc;
 
   *tablen = total_namelen;
   strptr = *tabloc;


@@ -1638,34 +1653,34 @@ _bfd_construct_extended_name_table (bfd *abfd,
       const char *normal;
       unsigned int thislen;
       long stroff;
       const char *normal;
       unsigned int thislen;
       long stroff;

-      const char *filename = current->filename;
+      const char *filename = bfd_get_filename (current);

 
       if (bfd_is_thin_archive (abfd))
 
       if (bfd_is_thin_archive (abfd))

-        {
-          /* If the element being added is a member of another archive
-             (i.e., we are flattening), use the containing archive's name.  */
-          if (current->my_archive
-              && ! bfd_is_thin_archive (current->my_archive))
-            filename = current->my_archive->filename;
-          /* If the path is the same as the previous path seen,
-             reuse it.  This can happen when flattening a thin
-             archive that contains other archives.
-             If the path is relative, adjust it relative to
-             the containing archive.  */
-          if (last_filename && filename_cmp (last_filename, filename) == 0)
-            normal = last_filename;
-          else if (! IS_ABSOLUTE_PATH (filename)
-                   && ! IS_ABSOLUTE_PATH (abfd->filename))
-            normal = adjust_relative_path (filename, abfd->filename);
-          else
-            normal = filename;
-        }
+       {
+         /* If the element being added is a member of another archive
+            (i.e., we are flattening), use the containing archive's name.  */
+         if (current->my_archive
+             && ! bfd_is_thin_archive (current->my_archive))
+           filename = bfd_get_filename (current->my_archive);
+         /* If the path is the same as the previous path seen,
+            reuse it.  This can happen when flattening a thin
+            archive that contains other archives.
+            If the path is relative, adjust it relative to
+            the containing archive.  */
+         if (last_filename && filename_cmp (last_filename, filename) == 0)
+           normal = last_filename;
+         else if (! IS_ABSOLUTE_PATH (filename)
+                  && ! IS_ABSOLUTE_PATH (bfd_get_filename (abfd)))
+           normal = adjust_relative_path (filename, bfd_get_filename (abfd));
+         else
+           normal = filename;
+       }

       else
       else

-        {
-          normal = normalize (current, filename);
-          if (normal == NULL)
-            return FALSE;
-        }
+       {
+         normal = normalize (abfd, filename);
+         if (normal == NULL)
+           return false;
+       }

 
       thislen = strlen (normal);
       if (thislen > maxname || bfd_is_thin_archive (abfd))
 
       thislen = strlen (normal);
       if (thislen > maxname || bfd_is_thin_archive (abfd))


@@ -1676,51 +1691,42 @@ _bfd_construct_extended_name_table (bfd *abfd,
          struct ar_hdr *hdr = arch_hdr (current);
          if (normal == last_filename)
            stroff = last_stroff;
          struct ar_hdr *hdr = arch_hdr (current);
          if (normal == last_filename)
            stroff = last_stroff;

-          else
-            {
-             strcpy (strptr, normal);
-             if (! trailing_slash)
-               strptr[thislen] = ARFMAG[1];
-             else
-               {
-                 strptr[thislen] = '/';
-                 strptr[thislen + 1] = ARFMAG[1];
-               }
+         else
+           {
+             last_filename = filename;

              stroff = strptr - *tabloc;
              last_stroff = stroff;
              stroff = strptr - *tabloc;
              last_stroff = stroff;

+             memcpy (strptr, normal, thislen);
+             strptr += thislen;
+             if (trailing_slash)
+               *strptr++ = '/';
+             *strptr++ = ARFMAG[1];

            }
          hdr->ar_name[0] = ar_padchar (current);
          if (bfd_is_thin_archive (abfd) && current->origin > 0)
            {
              int len = snprintf (hdr->ar_name + 1, maxname - 1, "%-ld:",
            }
          hdr->ar_name[0] = ar_padchar (current);
          if (bfd_is_thin_archive (abfd) && current->origin > 0)
            {
              int len = snprintf (hdr->ar_name + 1, maxname - 1, "%-ld:",

-                                 stroff);
+                                 stroff);

              _bfd_ar_spacepad (hdr->ar_name + 1 + len, maxname - 1 - len,
              _bfd_ar_spacepad (hdr->ar_name + 1 + len, maxname - 1 - len,

-                                "%-ld",
-                                current->origin - sizeof (struct ar_hdr));
+                               "%-ld",
+                               current->origin - sizeof (struct ar_hdr));

            }
          else
            }
          else

-            _bfd_ar_spacepad (hdr->ar_name + 1, maxname - 1, "%-ld", stroff);
-          if (normal != last_filename)
-            {
-             strptr += thislen + 1;
-             if (trailing_slash)
-               ++strptr;
-              last_filename = filename;
-           }
+           _bfd_ar_spacepad (hdr->ar_name + 1, maxname - 1, "%-ld", stroff);

        }
     }
 
        }
     }
 

-  return TRUE;
+  return true;

 }
 
 /* Do not construct an extended name table but transforms name field into
    its extended form.  */
 
 }
 
 /* Do not construct an extended name table but transforms name field into
    its extended form.  */
 

-bfd_boolean
+bool

 _bfd_archive_bsd44_construct_extended_name_table (bfd *abfd,
 _bfd_archive_bsd44_construct_extended_name_table (bfd *abfd,

-                                                  char **tabloc,
-                                                  bfd_size_type *tablen,
-                                                  const char **name)
+                                                 char **tabloc,
+                                                 bfd_size_type *tablen,
+                                                 const char **name)

 {
   unsigned int maxname = ar_maxnamelen (abfd);
   bfd *current;
 {
   unsigned int maxname = ar_maxnamelen (abfd);
   bfd *current;


@@ -1733,45 +1739,45 @@ _bfd_archive_bsd44_construct_extended_name_table (bfd *abfd,
        current != NULL;
        current = current->archive_next)
     {
        current != NULL;
        current = current->archive_next)
     {

-      const char *normal = normalize (current, current->filename);
+      const char *normal = normalize (abfd, bfd_get_filename (current));

       int has_space = 0;
       unsigned int len;
 
       if (normal == NULL)
       int has_space = 0;
       unsigned int len;
 
       if (normal == NULL)

-       return FALSE;
+       return false;

 
       for (len = 0; normal[len]; len++)
 
       for (len = 0; normal[len]; len++)

-        if (normal[len] == ' ')
-          has_space = 1;
+       if (normal[len] == ' ')
+         has_space = 1;

 
       if (len > maxname || has_space)
        {
 
       if (len > maxname || has_space)
        {

-          struct ar_hdr *hdr = arch_hdr (current);
+         struct ar_hdr *hdr = arch_hdr (current);

 
 

-          len = (len + 3) & ~3;
-          arch_eltdata (current)->extra_size = len;
-          _bfd_ar_spacepad (hdr->ar_name, maxname, "#1/%lu", len);
+         len = (len + 3) & ~3;
+         arch_eltdata (current)->extra_size = len;
+         _bfd_ar_spacepad (hdr->ar_name, maxname, "#1/%lu", len);

        }
     }
 
        }
     }
 

-  return TRUE;
+  return true;

 }
 \f
 /* Write an archive header.  */
 
 }
 \f
 /* Write an archive header.  */
 

-bfd_boolean
+bool

 _bfd_generic_write_ar_hdr (bfd *archive, bfd *abfd)
 {
   struct ar_hdr *hdr = arch_hdr (abfd);
 
   if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
 _bfd_generic_write_ar_hdr (bfd *archive, bfd *abfd)
 {
   struct ar_hdr *hdr = arch_hdr (abfd);
 
   if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))

-    return FALSE;
-  return TRUE;
+    return false;
+  return true;

 }
 
 /* Write an archive header using BSD4.4 convention.  */
 
 }
 
 /* Write an archive header using BSD4.4 convention.  */
 

-bfd_boolean
+bool

 _bfd_bsd44_write_ar_hdr (bfd *archive, bfd *abfd)
 {
   struct ar_hdr *hdr = arch_hdr (abfd);
 _bfd_bsd44_write_ar_hdr (bfd *archive, bfd *abfd)
 {
   struct ar_hdr *hdr = arch_hdr (abfd);


@@ -1779,37 +1785,43 @@ _bfd_bsd44_write_ar_hdr (bfd *archive, bfd *abfd)
   if (is_bsd44_extended_name (hdr->ar_name))
     {
       /* This is a BSD 4.4 extended name.  */
   if (is_bsd44_extended_name (hdr->ar_name))
     {
       /* This is a BSD 4.4 extended name.  */

-      const char *fullname = normalize (abfd, abfd->filename);
+      const char *fullname = normalize (abfd, bfd_get_filename (abfd));

       unsigned int len = strlen (fullname);
       unsigned int padded_len = (len + 3) & ~3;
 
       BFD_ASSERT (padded_len == arch_eltdata (abfd)->extra_size);
 
       if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size),
       unsigned int len = strlen (fullname);
       unsigned int padded_len = (len + 3) & ~3;
 
       BFD_ASSERT (padded_len == arch_eltdata (abfd)->extra_size);
 
       if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size),

-                            arch_eltdata (abfd)->parsed_size + padded_len))
-        return FALSE;
+                           arch_eltdata (abfd)->parsed_size + padded_len))
+       return false;

 
       if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
 
       if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))

-        return FALSE;
+       return false;

 
       if (bfd_bwrite (fullname, len, archive) != len)
 
       if (bfd_bwrite (fullname, len, archive) != len)

-        return FALSE;
+       return false;

 
       if (len & 3)
 
       if (len & 3)

-        {
-          static const char pad[3] = { 0, 0, 0 };
+       {
+         static const char pad[3] = { 0, 0, 0 };

 
 

-          len = 4 - (len & 3);
-          if (bfd_bwrite (pad, len, archive) != len)
-            return FALSE;
-        }
+         len = 4 - (len & 3);
+         if (bfd_bwrite (pad, len, archive) != len)
+           return false;
+       }

     }
   else
     {
       if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
     }
   else
     {
       if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))

-        return FALSE;
+       return false;

     }
     }

-  return TRUE;
+  return true;
+}
+
+bool
+_bfd_noarchive_write_ar_hdr (bfd *archive, bfd *abfd ATTRIBUTE_UNUSED)
+{
+  return _bfd_bool_bfd_false_error (archive);

 }
 \f
 /* A couple of functions for creating ar_hdrs.  */
 }
 \f
 /* A couple of functions for creating ar_hdrs.  */


@@ -1830,14 +1842,6 @@ hpux_uid_gid_encode (char str[6], long int id)
 }
 #endif /* HPUX_LARGE_AR_IDS */
 
 }
 #endif /* HPUX_LARGE_AR_IDS */
 

-#ifndef HAVE_GETUID
-#define getuid() 0
-#endif
-
-#ifndef HAVE_GETGID
-#define getgid() 0
-#endif
-

 /* Takes a filename, returns an arelt_data for it, or NULL if it can't
    make one.  The filename must refer to a filename in the filesystem.
    The filename field of the ar_hdr will NOT be initialized.  If member
 /* Takes a filename, returns an arelt_data for it, or NULL if it can't
    make one.  The filename must refer to a filename in the filesystem.
    The filename field of the ar_hdr will NOT be initialized.  If member


@@ -1849,7 +1853,7 @@ bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
   struct stat status;
   struct areltdata *ared;
   struct ar_hdr *hdr;
   struct stat status;
   struct areltdata *ared;
   struct ar_hdr *hdr;

-  bfd_size_type amt;
+  size_t amt;

 
   if (member && (member->flags & BFD_IN_MEMORY) != 0)
     {
 
   if (member && (member->flags & BFD_IN_MEMORY) != 0)
     {


@@ -1863,7 +1867,7 @@ bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
     }
   else if (stat (filename, &status) != 0)
     {
     }
   else if (stat (filename, &status) != 0)
     {

-      bfd_set_error (bfd_error_system_call);
+      bfd_set_input_error (member, bfd_error_system_call);

       return NULL;
     }
 
       return NULL;
     }
 


@@ -1878,7 +1882,7 @@ bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
     }
 
   amt = sizeof (struct ar_hdr) + sizeof (struct areltdata);
     }
 
   amt = sizeof (struct ar_hdr) + sizeof (struct areltdata);

-  ared = (struct areltdata *) bfd_zalloc (abfd, amt);
+  ared = (struct areltdata *) bfd_zmalloc (amt);

   if (ared == NULL)
     return NULL;
   hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));
   if (ared == NULL)
     return NULL;
   hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));


@@ -1887,7 +1891,7 @@ bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
   memset (hdr, ' ', sizeof (struct ar_hdr));
 
   _bfd_ar_spacepad (hdr->ar_date, sizeof (hdr->ar_date), "%-12ld",
   memset (hdr, ' ', sizeof (struct ar_hdr));
 
   _bfd_ar_spacepad (hdr->ar_date, sizeof (hdr->ar_date), "%-12ld",

-                    status.st_mtime);
+                   status.st_mtime);

 #ifdef HPUX_LARGE_AR_IDS
   /* HP has a very "special" way to handle UID/GID's with numeric values
      > 99999.  */
 #ifdef HPUX_LARGE_AR_IDS
   /* HP has a very "special" way to handle UID/GID's with numeric values
      > 99999.  */


@@ -1896,7 +1900,7 @@ bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
   else
 #endif
     _bfd_ar_spacepad (hdr->ar_uid, sizeof (hdr->ar_uid), "%ld",
   else
 #endif
     _bfd_ar_spacepad (hdr->ar_uid, sizeof (hdr->ar_uid), "%ld",

-                      status.st_uid);
+                     status.st_uid);

 #ifdef HPUX_LARGE_AR_IDS
   /* HP has a very "special" way to handle UID/GID's with numeric values
      > 99999.  */
 #ifdef HPUX_LARGE_AR_IDS
   /* HP has a very "special" way to handle UID/GID's with numeric values
      > 99999.  */


@@ -1905,9 +1909,15 @@ bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
   else
 #endif
     _bfd_ar_spacepad (hdr->ar_gid, sizeof (hdr->ar_gid), "%ld",
   else
 #endif
     _bfd_ar_spacepad (hdr->ar_gid, sizeof (hdr->ar_gid), "%ld",

-                      status.st_gid);
+                     status.st_gid);

   _bfd_ar_spacepad (hdr->ar_mode, sizeof (hdr->ar_mode), "%-8lo",
   _bfd_ar_spacepad (hdr->ar_mode, sizeof (hdr->ar_mode), "%-8lo",

-                    status.st_mode);
+                   status.st_mode);
+  if (status.st_size - (bfd_size_type) status.st_size != 0)
+    {
+      bfd_set_error (bfd_error_file_too_big);
+      free (ared);
+      return NULL;
+    }

   if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size), status.st_size))
     {
       free (ared);
   if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size), status.st_size))
     {
       free (ared);


@@ -1935,10 +1945,12 @@ bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
     }
 
   hdr = arch_hdr (abfd);
     }
 
   hdr = arch_hdr (abfd);

-
+  /* PR 17512: file: 3d9e9fe9.  */
+  if (hdr == NULL)
+    return -1;

 #define foo(arelt, stelt, size)                                \
   buf->stelt = strtol (hdr->arelt, &aloser, size);     \
 #define foo(arelt, stelt, size)                                \
   buf->stelt = strtol (hdr->arelt, &aloser, size);     \

-  if (aloser == hdr->arelt)                            \
+  if (aloser == hdr->arelt)                            \

     return -1;
 
   /* Some platforms support special notations for large IDs.  */
     return -1;
 
   /* Some platforms support special notations for large IDs.  */


@@ -2073,19 +2085,26 @@ bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
   if (length < 16)
     (hdr->ar_name)[length] = ar_padchar (abfd);
 }
   if (length < 16)
     (hdr->ar_name)[length] = ar_padchar (abfd);
 }

+
+void
+_bfd_noarchive_truncate_arname (bfd *abfd ATTRIBUTE_UNUSED,
+                               const char *pathname ATTRIBUTE_UNUSED,
+                               char *arhdr ATTRIBUTE_UNUSED)
+{
+}

 \f
 /* The BFD is open for write and has its format set to bfd_archive.  */
 
 \f
 /* The BFD is open for write and has its format set to bfd_archive.  */
 

-bfd_boolean
+bool

 _bfd_write_archive_contents (bfd *arch)
 {
   bfd *current;
   char *etable = NULL;
   bfd_size_type elength = 0;
   const char *ename = NULL;
 _bfd_write_archive_contents (bfd *arch)
 {
   bfd *current;
   char *etable = NULL;
   bfd_size_type elength = 0;
   const char *ename = NULL;

-  bfd_boolean makemap = bfd_has_map (arch);
+  bool makemap = bfd_has_map (arch);

   /* If no .o's, don't bother to make a map.  */
   /* If no .o's, don't bother to make a map.  */

-  bfd_boolean hasobjects = FALSE;
+  bool hasobjects = false;

   bfd_size_type wrote;
   int tries;
   char *armag;
   bfd_size_type wrote;
   int tries;
   char *armag;


@@ -2110,39 +2129,41 @@ _bfd_write_archive_contents (bfd *arch)
       if (!current->arelt_data)
        {
          current->arelt_data =
       if (!current->arelt_data)
        {
          current->arelt_data =

-           bfd_ar_hdr_from_filesystem (arch, current->filename, current);
+           bfd_ar_hdr_from_filesystem (arch, bfd_get_filename (current),
+                                       current);

          if (!current->arelt_data)
            goto input_err;
 
          /* Put in the file name.  */
          BFD_SEND (arch, _bfd_truncate_arname,
          if (!current->arelt_data)
            goto input_err;
 
          /* Put in the file name.  */
          BFD_SEND (arch, _bfd_truncate_arname,

-                   (arch, current->filename, (char *) arch_hdr (current)));
+                   (arch, bfd_get_filename (current),
+                    (char *) arch_hdr (current)));

        }
 
       if (makemap && ! hasobjects)
        {                       /* Don't bother if we won't make a map!  */
          if ((bfd_check_format (current, bfd_object)))
        }
 
       if (makemap && ! hasobjects)
        {                       /* Don't bother if we won't make a map!  */
          if ((bfd_check_format (current, bfd_object)))

-           hasobjects = TRUE;
+           hasobjects = true;

        }
     }
 
   if (!BFD_SEND (arch, _bfd_construct_extended_name_table,
                 (arch, &etable, &elength, &ename)))
        }
     }
 
   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)
 
   if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0)

-    return FALSE;
+    return false;

   armag = ARMAG;
   if (bfd_is_thin_archive (arch))
     armag = ARMAGT;
   wrote = bfd_bwrite (armag, SARMAG, arch);
   if (wrote != SARMAG)
   armag = ARMAG;
   if (bfd_is_thin_archive (arch))
     armag = ARMAGT;
   wrote = bfd_bwrite (armag, SARMAG, arch);
   if (wrote != SARMAG)

-    return FALSE;
+    return false;

 
   if (makemap && hasobjects)
     {
       if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength))
 
   if (makemap && hasobjects)
     {
       if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength))

-       return FALSE;
+       return false;

     }
 
   if (elength != 0)
     }
 
   if (elength != 0)


@@ -2153,17 +2174,17 @@ _bfd_write_archive_contents (bfd *arch)
       memcpy (hdr.ar_name, ename, strlen (ename));
       /* Round size up to even number in archive header.  */
       if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size),
       memcpy (hdr.ar_name, ename, strlen (ename));
       /* Round size up to even number in archive header.  */
       if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size),

-                            (elength + 1) & ~(bfd_size_type) 1))
-        return FALSE;
+                           (elength + 1) & ~(bfd_size_type) 1))
+       return false;

       memcpy (hdr.ar_fmag, ARFMAG, 2);
       if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
           != sizeof (struct ar_hdr))
          || bfd_bwrite (etable, elength, arch) != elength)
       memcpy (hdr.ar_fmag, ARFMAG, 2);
       if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
           != sizeof (struct ar_hdr))
          || bfd_bwrite (etable, elength, arch) != elength)

-       return FALSE;
+       return false;

       if ((elength % 2) == 1)
        {
          if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)
       if ((elength % 2) == 1)
        {
          if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)

-           return FALSE;
+           return false;

        }
     }
 
        }
     }
 


@@ -2176,34 +2197,30 @@ _bfd_write_archive_contents (bfd *arch)
 
       /* Write ar header.  */
       if (!_bfd_write_ar_hdr (arch, current))
 
       /* Write ar header.  */
       if (!_bfd_write_ar_hdr (arch, current))

-        return FALSE;
+       return false;

       if (bfd_is_thin_archive (arch))
       if (bfd_is_thin_archive (arch))

-        continue;
+       continue;

       if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
        goto input_err;
 
       while (remaining)
        {
       if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
        goto input_err;
 
       while (remaining)
        {

-         unsigned int amt = DEFAULT_BUFFERSIZE;
+         size_t amt = DEFAULT_BUFFERSIZE;

 
          if (amt > remaining)
            amt = remaining;
          errno = 0;
          if (bfd_bread (buffer, amt, current) != amt)
 
          if (amt > remaining)
            amt = remaining;
          errno = 0;
          if (bfd_bread (buffer, amt, current) != amt)

-           {
-             if (bfd_get_error () != bfd_error_system_call)
-               bfd_set_error (bfd_error_file_truncated);
-             goto input_err;
-           }
+           goto input_err;

          if (bfd_bwrite (buffer, amt, arch) != amt)
          if (bfd_bwrite (buffer, amt, arch) != amt)

-           return FALSE;
+           return false;

          remaining -= amt;
        }
 
       if ((arelt_size (current) % 2) == 1)
        {
          if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)
          remaining -= amt;
        }
 
       if ((arelt_size (current) % 2) == 1)
        {
          if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)

-           return FALSE;
+           return false;

        }
     }
 
        }
     }
 


@@ -2220,22 +2237,22 @@ _bfd_write_archive_contents (bfd *arch)
        {
          if (bfd_update_armap_timestamp (arch))
            break;
        {
          if (bfd_update_armap_timestamp (arch))
            break;

-         (*_bfd_error_handler)
-           (_("Warning: writing archive was slow: rewriting timestamp\n"));
+         _bfd_error_handler
+           (_("warning: writing archive was slow: rewriting timestamp"));

        }
       while (++tries < 6);
     }
 
        }
       while (++tries < 6);
     }
 

-  return TRUE;
+  return true;

 
  input_err:
 
  input_err:

-  bfd_set_error (bfd_error_on_input, current, bfd_get_error ());
-  return FALSE;
+  bfd_set_input_error (current, bfd_get_error ());
+  return false;

 }
 \f
 /* Note that the namidx for the first symbol is 0.  */
 
 }
 \f
 /* Note that the namidx for the first symbol is 0.  */
 

-bfd_boolean
+bool

 _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
 {
   char *first_name = NULL;
 _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
 {
   char *first_name = NULL;


@@ -2247,8 +2264,9 @@ _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
   int stridx = 0;
   asymbol **syms = NULL;
   long syms_max = 0;
   int stridx = 0;
   asymbol **syms = NULL;
   long syms_max = 0;

-  bfd_boolean ret;
-  bfd_size_type amt;
+  bool ret;
+  size_t amt;
+  static bool report_plugin_err = true;

 
   /* Dunno if this is the best place for this info...  */
   if (elength != 0)
 
   /* Dunno if this is the best place for this info...  */
   if (elength != 0)


@@ -2268,7 +2286,7 @@ _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
 
   /* Drop all the files called __.SYMDEF, we're going to make our own.  */
   while (arch->archive_head
 
   /* Drop all the files called __.SYMDEF, we're going to make our own.  */
   while (arch->archive_head

-        && strcmp (arch->archive_head->filename, "__.SYMDEF") == 0)
+        && strcmp (bfd_get_filename (arch->archive_head), "__.SYMDEF") == 0)

     arch->archive_head = arch->archive_head->archive_next;
 
   /* Map over each element.  */
     arch->archive_head = arch->archive_head->archive_next;
 
   /* Map over each element.  */


@@ -2283,6 +2301,14 @@ _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
          long symcount;
          long src_count;
 
          long symcount;
          long src_count;
 

+         if (current->lto_slim_object && report_plugin_err)
+           {
+             report_plugin_err = false;
+             _bfd_error_handler
+               (_("%pB: plugin needed to handle lto object"),
+                current);
+           }
+

          storage = bfd_get_symtab_upper_bound (current);
          if (storage < 0)
            goto error_return;
          storage = bfd_get_symtab_upper_bound (current);
          if (storage < 0)
            goto error_return;


@@ -2291,8 +2317,7 @@ _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
            {
              if (storage > syms_max)
                {
            {
              if (storage > syms_max)
                {

-                 if (syms_max > 0)
-                   free (syms);
+                 free (syms);

                  syms_max = storage;
                  syms = (asymbol **) bfd_malloc (syms_max);
                  if (syms == NULL)
                  syms_max = storage;
                  syms = (asymbol **) bfd_malloc (syms_max);
                  if (syms == NULL)


@@ -2303,16 +2328,16 @@ _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
                goto error_return;
 
              /* Now map over all the symbols, picking out the ones we
                goto error_return;
 
              /* Now map over all the symbols, picking out the ones we

-                 want.  */
+                want.  */

              for (src_count = 0; src_count < symcount; src_count++)
                {
                  flagword flags = (syms[src_count])->flags;
                  asection *sec = syms[src_count]->section;
 
              for (src_count = 0; src_count < symcount; src_count++)
                {
                  flagword flags = (syms[src_count])->flags;
                  asection *sec = syms[src_count]->section;
 

-                 if ((flags & BSF_GLOBAL
-                      || flags & BSF_WEAK
-                      || flags & BSF_INDIRECT
-                      || flags & BSF_GNU_UNIQUE
+                 if (((flags & (BSF_GLOBAL
+                                | BSF_WEAK
+                                | BSF_INDIRECT
+                                | BSF_GNU_UNIQUE)) != 0

                       || bfd_is_com_section (sec))
                      && ! bfd_is_und_section (sec))
                    {
                       || bfd_is_com_section (sec))
                      && ! bfd_is_und_section (sec))
                    {


@@ -2331,13 +2356,25 @@ _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
                          map = new_map;
                        }
 
                          map = new_map;
                        }
 

+                     if (syms[src_count]->name[0] == '_'
+                         && syms[src_count]->name[1] == '_'
+                         && strcmp (syms[src_count]->name
+                                    + (syms[src_count]->name[2] == '_'),
+                                    "__gnu_lto_slim") == 0
+                         && report_plugin_err)
+                       {
+                         report_plugin_err = false;
+                         _bfd_error_handler
+                           (_("%pB: plugin needed to handle lto object"),
+                            current);
+                       }

                      namelen = strlen (syms[src_count]->name);
                      amt = sizeof (char *);
                      map[orl_count].name = (char **) bfd_alloc (arch, amt);
                      if (map[orl_count].name == NULL)
                        goto error_return;
                      *(map[orl_count].name) = (char *) bfd_alloc (arch,
                      namelen = strlen (syms[src_count]->name);
                      amt = sizeof (char *);
                      map[orl_count].name = (char **) bfd_alloc (arch, amt);
                      if (map[orl_count].name == NULL)
                        goto error_return;
                      *(map[orl_count].name) = (char *) bfd_alloc (arch,

-                                                                   namelen + 1);
+                                                                  namelen + 1);

                      if (*(map[orl_count].name) == NULL)
                        goto error_return;
                      strcpy (*(map[orl_count].name), syms[src_count]->name);
                      if (*(map[orl_count].name) == NULL)
                        goto error_return;
                      strcpy (*(map[orl_count].name), syms[src_count]->name);


@@ -2361,47 +2398,77 @@ _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
   ret = BFD_SEND (arch, write_armap,
                  (arch, elength, map, orl_count, stridx));
 
   ret = BFD_SEND (arch, write_armap,
                  (arch, elength, map, orl_count, stridx));
 

-  if (syms_max > 0)
-    free (syms);
-  if (map != NULL)
-    free (map);
+  free (syms);
+  free (map);

   if (first_name != NULL)
     bfd_release (arch, first_name);
 
   return ret;
 
  error_return:
   if (first_name != NULL)
     bfd_release (arch, first_name);
 
   return ret;
 
  error_return:

-  if (syms_max > 0)
-    free (syms);
-  if (map != NULL)
-    free (map);
+  free (syms);
+  free (map);

   if (first_name != NULL)
     bfd_release (arch, first_name);
 
   if (first_name != NULL)
     bfd_release (arch, first_name);
 

-  return FALSE;
+  return false;

 }
 
 }
 

-bfd_boolean
-bsd_write_armap (bfd *arch,
-                unsigned int elength,
-                struct orl *map,
-                unsigned int orl_count,
-                int stridx)
+bool
+_bfd_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;
   unsigned int stringsize = stridx + padit;
   /* Include 8 bytes to store ranlibsize and stringsize in output.  */
   unsigned int mapsize = ranlibsize + stringsize + 8;
 {
   int padit = stridx & 1;
   unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE;
   unsigned int stringsize = stridx + padit;
   /* Include 8 bytes to store ranlibsize and stringsize in output.  */
   unsigned int mapsize = ranlibsize + stringsize + 8;

-  file_ptr firstreal;
-  bfd *current = arch->archive_head;
-  bfd *last_elt = current;     /* Last element arch seen.  */
+  file_ptr firstreal, first;
+  bfd *current;
+  bfd *last_elt;

   bfd_byte temp[4];
   unsigned int count;
   struct ar_hdr hdr;
   long uid, gid;
 
   bfd_byte temp[4];
   unsigned int count;
   struct ar_hdr hdr;
   long uid, gid;
 

-  firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
+  first = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
+
+#ifdef BFD64
+  firstreal = first;
+  current = arch->archive_head;
+  last_elt = current;  /* Last element arch seen.  */
+  for (count = 0; count < orl_count; count++)
+    {
+      unsigned int offset;
+
+      if (map[count].u.abfd != last_elt)
+       {
+         do
+           {
+             struct areltdata *ared = arch_eltdata (current);
+
+             firstreal += (ared->parsed_size + ared->extra_size
+                           + sizeof (struct ar_hdr));
+             firstreal += firstreal % 2;
+             current = current->archive_next;
+           }
+         while (current != map[count].u.abfd);
+       }
+
+      /* The archive file format only has 4 bytes to store the offset
+        of the member.  Generate 64-bit archive if an archive is past
+        its 4Gb limit.  */
+      offset = (unsigned int) firstreal;
+      if (firstreal != (file_ptr) offset)
+       return _bfd_archive_64_bit_write_armap (arch, elength, map,
+                                               orl_count, stridx);
+
+      last_elt = current;
+    }
+#endif

 
   /* If deterministic, we use 0 as the timestamp in the map.
      Some linkers may require that the archive filesystem modification
 
   /* If deterministic, we use 0 as the timestamp in the map.
      Some linkers may require that the archive filesystem modification


@@ -2415,7 +2482,7 @@ bsd_write_armap (bfd *arch,
     {
       struct stat statbuf;
 
     {
       struct stat statbuf;
 

-      if (stat (arch->filename, &statbuf) == 0)
+      if (stat (bfd_get_filename (arch), &statbuf) == 0)

        bfd_ardata (arch)->armap_timestamp = (statbuf.st_mtime
                                              + ARMAP_TIME_OFFSET);
       uid = getuid();
        bfd_ardata (arch)->armap_timestamp = (statbuf.st_mtime
                                              + ARMAP_TIME_OFFSET);
       uid = getuid();


@@ -2427,55 +2494,69 @@ bsd_write_armap (bfd *arch,
   bfd_ardata (arch)->armap_datepos = (SARMAG
                                      + offsetof (struct ar_hdr, ar_date[0]));
   _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
   bfd_ardata (arch)->armap_datepos = (SARMAG
                                      + offsetof (struct ar_hdr, ar_date[0]));
   _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",

-                    bfd_ardata (arch)->armap_timestamp);
+                   bfd_ardata (arch)->armap_timestamp);

   _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", uid);
   _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", gid);
   if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))
   _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", uid);
   _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", gid);
   if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))

-    return FALSE;
+    return false;

   memcpy (hdr.ar_fmag, ARFMAG, 2);
   if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
       != sizeof (struct ar_hdr))
   memcpy (hdr.ar_fmag, ARFMAG, 2);
   if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
       != sizeof (struct ar_hdr))

-    return FALSE;
+    return false;

   H_PUT_32 (arch, ranlibsize, temp);
   if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
   H_PUT_32 (arch, ranlibsize, temp);
   if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))

-    return FALSE;
+    return false;

 
 

+  firstreal = first;
+  current = arch->archive_head;
+  last_elt = current;  /* Last element arch seen.  */

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

+      unsigned int offset;

       bfd_byte buf[BSD_SYMDEF_SIZE];
 
       if (map[count].u.abfd != last_elt)
        {
          do
            {
       bfd_byte buf[BSD_SYMDEF_SIZE];
 
       if (map[count].u.abfd != last_elt)
        {
          do
            {

-              struct areltdata *ared = arch_eltdata (current);
+             struct areltdata *ared = arch_eltdata (current);

 
              firstreal += (ared->parsed_size + ared->extra_size
 
              firstreal += (ared->parsed_size + ared->extra_size

-                            + sizeof (struct ar_hdr));
+                           + sizeof (struct ar_hdr));

              firstreal += firstreal % 2;
              current = current->archive_next;
            }
          while (current != map[count].u.abfd);
        }
 
              firstreal += firstreal % 2;
              current = current->archive_next;
            }
          while (current != map[count].u.abfd);
        }
 

+      /* The archive file format only has 4 bytes to store the offset
+        of the member.  Check to make sure that firstreal has not grown
+        too big.  */
+      offset = (unsigned int) firstreal;
+      if (firstreal != (file_ptr) offset)
+       {
+         bfd_set_error (bfd_error_file_truncated);
+         return false;
+       }
+

       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, BSD_SYMDEF_SIZE, arch)
          != BSD_SYMDEF_SIZE)
       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, BSD_SYMDEF_SIZE, arch)
          != BSD_SYMDEF_SIZE)

-       return FALSE;
+       return false;

     }
 
   /* Now write the strings themselves.  */
   H_PUT_32 (arch, stringsize, temp);
   if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
     }
 
   /* Now write the strings themselves.  */
   H_PUT_32 (arch, stringsize, temp);
   if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))

-    return FALSE;
+    return false;

   for (count = 0; count < orl_count; count++)
     {
       size_t len = strlen (*map[count].name) + 1;
 
       if (bfd_bwrite (*map[count].name, len, arch) != len)
   for (count = 0; count < orl_count; count++)
     {
       size_t len = strlen (*map[count].name) + 1;
 
       if (bfd_bwrite (*map[count].name, len, arch) != len)

-       return FALSE;
+       return false;

     }
 
   /* The spec sez this should be a newline.  But in order to be
     }
 
   /* The spec sez this should be a newline.  But in order to be


@@ -2483,10 +2564,10 @@ bsd_write_armap (bfd *arch,
   if (padit)
     {
       if (bfd_bwrite ("", 1, arch) != 1)
   if (padit)
     {
       if (bfd_bwrite ("", 1, arch) != 1)

-       return FALSE;
+       return false;

     }
 
     }
 

-  return TRUE;
+  return true;

 }
 
 /* At the end of archive file handling, update the timestamp in the
 }
 
 /* At the end of archive file handling, update the timestamp in the


@@ -2495,7 +2576,7 @@ bsd_write_armap (bfd *arch,
    Return TRUE if the timestamp was OK, or an unusual problem happened.
    Return FALSE if we updated the timestamp.  */
 
    Return TRUE if the timestamp was OK, or an unusual problem happened.
    Return FALSE if we updated the timestamp.  */
 

-bfd_boolean
+bool

 _bfd_archive_bsd_update_armap_timestamp (bfd *arch)
 {
   struct stat archstat;
 _bfd_archive_bsd_update_armap_timestamp (bfd *arch)
 {
   struct stat archstat;


@@ -2503,7 +2584,7 @@ _bfd_archive_bsd_update_armap_timestamp (bfd *arch)
 
   /* If creating deterministic archives, just leave the timestamp as-is.  */
   if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) != 0)
 
   /* If creating deterministic archives, just leave the timestamp as-is.  */
   if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) != 0)

-    return TRUE;
+    return true;

 
   /* Flush writes, get last-write timestamp from file, and compare it
      to the timestamp IN the file.  */
 
   /* Flush writes, get last-write timestamp from file, and compare it
      to the timestamp IN the file.  */


@@ -2513,11 +2594,11 @@ _bfd_archive_bsd_update_armap_timestamp (bfd *arch)
       bfd_perror (_("Reading archive file mod timestamp"));
 
       /* Can't read mod time for some reason.  */
       bfd_perror (_("Reading archive file mod timestamp"));
 
       /* Can't read mod time for some reason.  */

-      return TRUE;
+      return true;

     }
   if (((long) archstat.st_mtime) <= bfd_ardata (arch)->armap_timestamp)
     /* OK by the linker's rules.  */
     }
   if (((long) archstat.st_mtime) <= bfd_ardata (arch)->armap_timestamp)
     /* OK by the linker's rules.  */

-    return TRUE;
+    return true;

 
   /* Update the timestamp.  */
   bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET;
 
   /* Update the timestamp.  */
   bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET;


@@ -2525,7 +2606,7 @@ _bfd_archive_bsd_update_armap_timestamp (bfd *arch)
   /* Prepare an ASCII version suitable for writing.  */
   memset (hdr.ar_date, ' ', sizeof (hdr.ar_date));
   _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
   /* Prepare an ASCII version suitable for writing.  */
   memset (hdr.ar_date, ' ', sizeof (hdr.ar_date));
   _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",

-                    bfd_ardata (arch)->armap_timestamp);
+                   bfd_ardata (arch)->armap_timestamp);

 
   /* Write it into the file.  */
   bfd_ardata (arch)->armap_datepos = (SARMAG
 
   /* Write it into the file.  */
   bfd_ardata (arch)->armap_datepos = (SARMAG


@@ -2537,11 +2618,11 @@ _bfd_archive_bsd_update_armap_timestamp (bfd *arch)
       bfd_perror (_("Writing updated armap timestamp"));
 
       /* Some error while writing.  */
       bfd_perror (_("Writing updated armap timestamp"));
 
       /* Some error while writing.  */

-      return TRUE;
+      return true;

     }
 
   /* We updated the timestamp successfully.  */
     }
 
   /* We updated the timestamp successfully.  */

-  return FALSE;
+  return false;

 }
 \f
 /* A coff armap looks like :
 }
 \f
 /* A coff armap looks like :


@@ -2557,19 +2638,20 @@ _bfd_archive_bsd_update_armap_timestamp (bfd *arch)
 
    symbol name n-1  */
 
 
    symbol name n-1  */
 

-bfd_boolean
-coff_write_armap (bfd *arch,
-                 unsigned int elength,
-                 struct orl *map,
-                 unsigned int symbol_count,
-                 int stridx)
+bool
+_bfd_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.  */
   unsigned int ranlibsize = (symbol_count * 4) + 4;
   unsigned int stringsize = stridx;
   unsigned int mapsize = stringsize + ranlibsize;
 {
   /* 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.  */
   unsigned int ranlibsize = (symbol_count * 4) + 4;
   unsigned int stringsize = stridx;
   unsigned int mapsize = stringsize + ranlibsize;

-  unsigned int archive_member_file_ptr;
+  file_ptr archive_member_file_ptr;
+  file_ptr first_archive_member_file_ptr;

   bfd *current = arch->archive_head;
   unsigned int count;
   struct ar_hdr hdr;
   bfd *current = arch->archive_head;
   unsigned int count;
   struct ar_hdr hdr;


@@ -2579,18 +2661,50 @@ coff_write_armap (bfd *arch,
     mapsize++;
 
   /* Work out where the first object file will go in the archive.  */
     mapsize++;
 
   /* Work out where the first object file will go in the archive.  */

-  archive_member_file_ptr = (mapsize
-                            + elength
-                            + sizeof (struct ar_hdr)
-                            + SARMAG);
+  first_archive_member_file_ptr = (mapsize
+                                  + elength
+                                  + sizeof (struct ar_hdr)
+                                  + SARMAG);
+
+#ifdef BFD64
+  current = arch->archive_head;
+  count = 0;
+  archive_member_file_ptr = first_archive_member_file_ptr;
+  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.  */
+
+      while (count < symbol_count && map[count].u.abfd == current)
+       {
+         unsigned int offset = (unsigned int) archive_member_file_ptr;
+
+         /* Generate 64-bit archive if an archive is past its 4Gb
+            limit.  */
+         if (archive_member_file_ptr != (file_ptr) offset)
+           return _bfd_archive_64_bit_write_armap (arch, elength, map,
+                                                   symbol_count, stridx);
+         count++;
+       }
+      archive_member_file_ptr += sizeof (struct ar_hdr);
+      if (! bfd_is_thin_archive (arch))
+       {
+         /* Add size of this archive entry.  */
+         archive_member_file_ptr += arelt_size (current);
+         /* Remember about the even alignment.  */
+         archive_member_file_ptr += archive_member_file_ptr % 2;
+       }
+      current = current->archive_next;
+    }
+#endif

 
   memset (&hdr, ' ', sizeof (struct ar_hdr));
   hdr.ar_name[0] = '/';
   if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))
 
   memset (&hdr, ' ', sizeof (struct ar_hdr));
   hdr.ar_name[0] = '/';
   if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))

-    return FALSE;
+    return false;

   _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
   _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",

-                    ((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0
-                     ? time (NULL) : 0));
+                   ((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0
+                    ? time (NULL) : 0));

   /* This, at least, is what Intel coff sets the values to.  */
   _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", 0);
   _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", 0);
   /* This, at least, is what Intel coff sets the values to.  */
   _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", 0);
   _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", 0);


@@ -2600,10 +2714,10 @@ coff_write_armap (bfd *arch,
   /* Write the ar header for this item and the number of symbols.  */
   if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
       != sizeof (struct ar_hdr))
   /* Write the ar header for this item and the number of symbols.  */
   if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
       != sizeof (struct ar_hdr))

-    return FALSE;
+    return false;

 
   if (!bfd_write_bigendian_4byte_int (arch, symbol_count))
 
   if (!bfd_write_bigendian_4byte_int (arch, symbol_count))

-    return FALSE;
+    return false;

 
   /* Two passes, first write the file offsets for each symbol -
      remembering that each offset is on a two byte boundary.  */
 
   /* Two passes, first write the file offsets for each symbol -
      remembering that each offset is on a two byte boundary.  */


@@ -2613,6 +2727,7 @@ coff_write_armap (bfd *arch,
 
   current = arch->archive_head;
   count = 0;
 
   current = arch->archive_head;
   count = 0;

+  archive_member_file_ptr = first_archive_member_file_ptr;

   while (current != NULL && count < symbol_count)
     {
       /* For each symbol which is used defined in this object, write
   while (current != NULL && count < symbol_count)
     {
       /* For each symbol which is used defined in this object, write


@@ -2620,18 +2735,26 @@ coff_write_armap (bfd *arch,
 
       while (count < symbol_count && map[count].u.abfd == current)
        {
 
       while (count < symbol_count && map[count].u.abfd == current)
        {

-         if (!bfd_write_bigendian_4byte_int (arch, archive_member_file_ptr))
-           return FALSE;
+         unsigned int offset = (unsigned int) archive_member_file_ptr;
+
+         /* Catch an attempt to grow an archive past its 4Gb limit.  */
+         if (archive_member_file_ptr != (file_ptr) offset)
+           {
+             bfd_set_error (bfd_error_file_truncated);
+             return false;
+           }
+         if (!bfd_write_bigendian_4byte_int (arch, offset))
+           return false;

          count++;
        }
       archive_member_file_ptr += sizeof (struct ar_hdr);
       if (! bfd_is_thin_archive (arch))
          count++;
        }
       archive_member_file_ptr += sizeof (struct ar_hdr);
       if (! bfd_is_thin_archive (arch))

-        {
-          /* Add size of this archive entry.  */
-          archive_member_file_ptr += arelt_size (current);
-          /* Remember about the even alignment.  */
-          archive_member_file_ptr += archive_member_file_ptr % 2;
-        }
+       {
+         /* Add size of this archive entry.  */
+         archive_member_file_ptr += arelt_size (current);
+         /* Remember about the even alignment.  */
+         archive_member_file_ptr += archive_member_file_ptr % 2;
+       }

       current = current->archive_next;
     }
 
       current = current->archive_next;
     }
 


@@ -2641,7 +2764,7 @@ coff_write_armap (bfd *arch,
       size_t len = strlen (*map[count].name) + 1;
 
       if (bfd_bwrite (*map[count].name, len, arch) != len)
       size_t len = strlen (*map[count].name) + 1;
 
       if (bfd_bwrite (*map[count].name, len, arch) != len)

-       return FALSE;
+       return false;

     }
 
   /* The spec sez this should be a newline.  But in order to be
     }
 
   /* The spec sez this should be a newline.  But in order to be


@@ -2649,8 +2772,85 @@ coff_write_armap (bfd *arch,
   if (padit)
     {
       if (bfd_bwrite ("", 1, arch) != 1)
   if (padit)
     {
       if (bfd_bwrite ("", 1, arch) != 1)

-       return FALSE;
+       return false;
+    }
+
+  return true;
+}
+
+bool
+_bfd_noarchive_write_armap
+    (bfd *arch ATTRIBUTE_UNUSED,
+     unsigned int elength ATTRIBUTE_UNUSED,
+     struct orl *map ATTRIBUTE_UNUSED,
+     unsigned int orl_count ATTRIBUTE_UNUSED,
+     int stridx ATTRIBUTE_UNUSED)
+{
+  return true;
+}
+
+static int
+archive_close_worker (void **slot, void *inf ATTRIBUTE_UNUSED)
+{
+  struct ar_cache *ent = (struct ar_cache *) *slot;
+
+  bfd_close_all_done (ent->arbfd);
+  return 1;
+}
+
+void
+_bfd_unlink_from_archive_parent (bfd *abfd)
+{
+  if (arch_eltdata (abfd) != NULL)
+    {
+      struct areltdata *ared = arch_eltdata (abfd);
+      htab_t htab = (htab_t) ared->parent_cache;
+
+      if (htab)
+       {
+         struct ar_cache ent;
+         void **slot;
+
+         ent.ptr = ared->key;
+         slot = htab_find_slot (htab, &ent, NO_INSERT);
+         if (slot != NULL)
+           {
+             BFD_ASSERT (((struct ar_cache *) *slot)->arbfd == abfd);
+             htab_clear_slot (htab, slot);
+           }
+       }
+    }
+}
+
+bool
+_bfd_archive_close_and_cleanup (bfd *abfd)
+{
+  if (bfd_read_p (abfd) && abfd->format == bfd_archive)
+    {
+      bfd *nbfd;
+      bfd *next;
+      htab_t htab;
+
+      /* Close nested archives (if this bfd is a thin archive).  */
+      for (nbfd = abfd->nested_archives; nbfd; nbfd = next)
+       {
+         next = nbfd->archive_next;
+         bfd_close (nbfd);
+       }
+
+      htab = bfd_ardata (abfd)->cache;
+      if (htab)
+       {
+         htab_traverse_noresize (htab, archive_close_worker, NULL);
+         htab_delete (htab);
+         bfd_ardata (abfd)->cache = NULL;
+       }

     }
 
     }
 

-  return TRUE;
+  _bfd_unlink_from_archive_parent (abfd);
+
+  if (abfd->is_linker_output)
+    (*abfd->link.hash->hash_table_free) (abfd);
+
+  return true;

 }
 }