bfd/archive.c

   1 /* BFD back-end for archive files (libraries).
   2    Copyright (C) 1990-2014 Free Software Foundation, Inc.
   3    Written by Cygnus Support.  Mostly Gumby Henkel-Wallace's fault.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  20
  21 /*
  22 @setfilename archive-info
  23 SECTION
  24         Archives
  25
  26 DESCRIPTION
  27         An archive (or library) is just another BFD.  It has a symbol
  28         table, although there's not much a user program will do with it.
  29
  30         The big difference between an archive BFD and an ordinary BFD
  31         is that the archive doesn't have sections.  Instead it has a
  32         chain of BFDs that are considered its contents.  These BFDs can
  33         be manipulated like any other.  The BFDs contained in an
  34         archive opened for reading will all be opened for reading.  You
  35         may put either input or output BFDs into an archive opened for
  36         output; they will be handled correctly when the archive is closed.
  37
  38         Use <<bfd_openr_next_archived_file>> to step through
  39         the contents of an archive opened for input.  You don't
  40         have to read the entire archive if you don't want
  41         to!  Read it until you find what you want.
  42
  43         A BFD returned by <<bfd_openr_next_archived_file>> can be
  44         closed manually with <<bfd_close>>.  If you do not close it,
  45         then a second iteration through the members of an archive may
  46         return the same BFD.  If you close the archive BFD, then all
  47         the member BFDs will automatically be closed as well.
  48
  49         Archive contents of output BFDs are chained through the
  50         <<archive_next>> pointer in a BFD.  The first one is findable
  51         through the <<archive_head>> slot of the archive.  Set it with
  52         <<bfd_set_archive_head>> (q.v.).  A given BFD may be in only
  53         one open output archive at a time.
  54
  55         As expected, the BFD archive code is more general than the
  56         archive code of any given environment.  BFD archives may
  57         contain files of different formats (e.g., a.out and coff) and
  58         even different architectures.  You may even place archives
  59         recursively into archives!
  60
  61         This can cause unexpected confusion, since some archive
  62         formats are more expressive than others.  For instance, Intel
  63         COFF archives can preserve long filenames; SunOS a.out archives
  64         cannot.  If you move a file from the first to the second
  65         format and back again, the filename may be truncated.
  66         Likewise, different a.out environments have different
  67         conventions as to how they truncate filenames, whether they
  68         preserve directory names in filenames, etc.  When
  69         interoperating with native tools, be sure your files are
  70         homogeneous.
  71
  72         Beware: most of these formats do not react well to the
  73         presence of spaces in filenames.  We do the best we can, but
  74         can't always handle this case due to restrictions in the format of
  75         archives.  Many Unix utilities are braindead in regards to
  76         spaces and such in filenames anyway, so this shouldn't be much
  77         of a restriction.
  78
  79         Archives are supported in BFD in <<archive.c>>.
  80
  81 SUBSECTION
  82         Archive functions
  83 */
  84
  85 /* Assumes:
  86    o - all archive elements start on an even boundary, newline padded;
  87    o - all arch headers are char *;
  88    o - all arch headers are the same size (across architectures).
  89 */
  90
  91 /* Some formats provide a way to cram a long filename into the short
  92    (16 chars) space provided by a BSD archive.  The trick is: make a
  93    special "file" in the front of the archive, sort of like the SYMDEF
  94    entry.  If the filename is too long to fit, put it in the extended
  95    name table, and use its index as the filename.  To prevent
  96    confusion prepend the index with a space.  This means you can't
  97    have filenames that start with a space, but then again, many Unix
  98    utilities can't handle that anyway.
  99
 100    This scheme unfortunately requires that you stand on your head in
 101    order to write an archive since you need to put a magic file at the
 102    front, and need to touch every entry to do so.  C'est la vie.
 103
 104    We support two variants of this idea:
 105    The SVR4 format (extended name table is named "//"),
 106    and an extended pseudo-BSD variant (extended name table is named
 107    "ARFILENAMES/").  The origin of the latter format is uncertain.
 108
 109    BSD 4.4 uses a third scheme:  It writes a long filename
 110    directly after the header.  This allows 'ar q' to work.
 111 */
 112
 113 /* Summary of archive member names:
 114
 115  Symbol table (must be first):
 116  "__.SYMDEF       " - Symbol table, Berkeley style, produced by ranlib.
 117  "/               " - Symbol table, system 5 style.
 118
 119  Long name table (must be before regular file members):
 120  "//              " - Long name table, System 5 R4 style.
 121  "ARFILENAMES/    " - Long name table, non-standard extended BSD (not BSD 4.4).
 122
 123  Regular file members with short names:
 124  "filename.o/     " - Regular file, System 5 style (embedded spaces ok).
 125  "filename.o      " - Regular file, Berkeley style (no embedded spaces).
 126
 127  Regular files with long names (or embedded spaces, for BSD variants):
 128  "/18             " - SVR4 style, name at offset 18 in name table.
 129  "#1/23           " - Long name (or embedded spaces) 23 characters long,
 130                       BSD 4.4 style, full name follows header.
 131  " 18             " - Long name 18 characters long, extended pseudo-BSD.
 132  */
 133
 134 #include "sysdep.h"
 135 #include "bfd.h"
 136 #include "libiberty.h"
 137 #include "libbfd.h"
 138 #include "aout/ar.h"
 139 #include "aout/ranlib.h"
 140 #include "safe-ctype.h"
 141 #include "hashtab.h"
 142 #include "filenames.h"
 143 #include "bfdlink.h"
 144
 145 #ifndef errno
 146 extern int errno;
 147 #endif
 148
 149 /* We keep a cache of archive filepointers to archive elements to
 150    speed up searching the archive by filepos.  We only add an entry to
 151    the cache when we actually read one.  We also don't sort the cache;
 152    it's generally short enough to search linearly.
 153    Note that the pointers here point to the front of the ar_hdr, not
 154    to the front of the contents!  */
 155 struct ar_cache
 156 {
 157   file_ptr ptr;
 158   bfd *arbfd;
 159 };
 160
 161 #define ar_padchar(abfd) ((abfd)->xvec->ar_pad_char)
 162 #define ar_maxnamelen(abfd) ((abfd)->xvec->ar_max_namelen)
 163
 164 #define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data))
 165 #define arch_hdr(bfd) ((struct ar_hdr *) arch_eltdata (bfd)->arch_header)
 166
 167 /* True iff NAME designated a BSD 4.4 extended name.  */
 168
 169 #define is_bsd44_extended_name(NAME) \
 170   (NAME[0] == '#'  && NAME[1] == '1' && NAME[2] == '/' && ISDIGIT (NAME[3]))
 171 \f
 172 void
 173 _bfd_ar_spacepad (char *p, size_t n, const char *fmt, long val)
 174 {
 175   static char buf[20];
 176   size_t len;
 177
 178   snprintf (buf, sizeof (buf), fmt, val);
 179   len = strlen (buf);
 180   if (len < n)
 181     {
 182       memcpy (p, buf, len);
 183       memset (p + len, ' ', n - len);
 184     }
 185   else
 186     memcpy (p, buf, n);
 187 }
 188
 189 bfd_boolean
 190 _bfd_ar_sizepad (char *p, size_t n, bfd_size_type size)
 191 {
 192   static char buf[21];
 193   size_t len;
 194
 195   snprintf (buf, sizeof (buf), "%-10" BFD_VMA_FMT "u", size);
 196   len = strlen (buf);
 197   if (len > n)
 198     {
 199       bfd_set_error (bfd_error_file_too_big);
 200       return FALSE;
 201     }
 202   if (len < n)
 203     {
 204       memcpy (p, buf, len);
 205       memset (p + len, ' ', n - len);
 206     }
 207   else
 208     memcpy (p, buf, n);
 209   return TRUE;
 210 }
 211 \f
 212 bfd_boolean
 213 _bfd_generic_mkarchive (bfd *abfd)
 214 {
 215   bfd_size_type amt = sizeof (struct artdata);
 216
 217   abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc (abfd, amt);
 218   if (bfd_ardata (abfd) == NULL)
 219     return FALSE;
 220
 221   /* Already cleared by bfd_zalloc above.
 222      bfd_ardata (abfd)->cache = NULL;
 223      bfd_ardata (abfd)->archive_head = NULL;
 224      bfd_ardata (abfd)->symdefs = NULL;
 225      bfd_ardata (abfd)->extended_names = NULL;
 226      bfd_ardata (abfd)->extended_names_size = 0;
 227      bfd_ardata (abfd)->tdata = NULL;  */
 228
 229   return TRUE;
 230 }
 231
 232 /*
 233 FUNCTION
 234         bfd_get_next_mapent
 235
 236 SYNOPSIS
 237         symindex bfd_get_next_mapent
 238           (bfd *abfd, symindex previous, carsym **sym);
 239
 240 DESCRIPTION
 241         Step through archive @var{abfd}'s symbol table (if it
 242         has one).  Successively update @var{sym} with the next symbol's
 243         information, returning that symbol's (internal) index into the
 244         symbol table.
 245
 246         Supply <<BFD_NO_MORE_SYMBOLS>> as the @var{previous} entry to get
 247         the first one; returns <<BFD_NO_MORE_SYMBOLS>> when you've already
 248         got the last one.
 249
 250         A <<carsym>> is a canonical archive symbol.  The only
 251         user-visible element is its name, a null-terminated string.
 252 */
 253
 254 symindex
 255 bfd_get_next_mapent (bfd *abfd, symindex prev, carsym **entry)
 256 {
 257   if (!bfd_has_map (abfd))
 258     {
 259       bfd_set_error (bfd_error_invalid_operation);
 260       return BFD_NO_MORE_SYMBOLS;
 261     }
 262
 263   if (prev == BFD_NO_MORE_SYMBOLS)
 264     prev = 0;
 265   else
 266     ++prev;
 267   if (prev >= bfd_ardata (abfd)->symdef_count)
 268     return BFD_NO_MORE_SYMBOLS;
 269
 270   *entry = (bfd_ardata (abfd)->symdefs + prev);
 271   return prev;
 272 }
 273
 274 /* To be called by backends only.  */
 275
 276 bfd *
 277 _bfd_create_empty_archive_element_shell (bfd *obfd)
 278 {
 279   return _bfd_new_bfd_contained_in (obfd);
 280 }
 281
 282 /*
 283 FUNCTION
 284         bfd_set_archive_head
 285
 286 SYNOPSIS
 287         bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);
 288
 289 DESCRIPTION
 290         Set the head of the chain of
 291         BFDs contained in the archive @var{output} to @var{new_head}.
 292 */
 293
 294 bfd_boolean
 295 bfd_set_archive_head (bfd *output_archive, bfd *new_head)
 296 {
 297   output_archive->archive_head = new_head;
 298   return TRUE;
 299 }
 300
 301 bfd *
 302 _bfd_look_for_bfd_in_cache (bfd *arch_bfd, file_ptr filepos)
 303 {
 304   htab_t hash_table = bfd_ardata (arch_bfd)->cache;
 305   struct ar_cache m;
 306
 307   m.ptr = filepos;
 308
 309   if (hash_table)
 310     {
 311       struct ar_cache *entry = (struct ar_cache *) htab_find (hash_table, &m);
 312       if (!entry)
 313         return NULL;
 314       else
 315         return entry->arbfd;
 316     }
 317   else
 318     return NULL;
 319 }
 320
 321 static hashval_t
 322 hash_file_ptr (const void * p)
 323 {
 324   return (hashval_t) (((struct ar_cache *) p)->ptr);
 325 }
 326
 327 /* Returns non-zero if P1 and P2 are equal.  */
 328
 329 static int
 330 eq_file_ptr (const void * p1, const void * p2)
 331 {
 332   struct ar_cache *arc1 = (struct ar_cache *) p1;
 333   struct ar_cache *arc2 = (struct ar_cache *) p2;
 334   return arc1->ptr == arc2->ptr;
 335 }
 336
 337 /* The calloc function doesn't always take size_t (e.g. on VMS)
 338    so wrap it to avoid a compile time warning.   */
 339
 340 static void *
 341 _bfd_calloc_wrapper (size_t a, size_t b)
 342 {
 343   return calloc (a, b);
 344 }
 345
 346 /* Kind of stupid to call cons for each one, but we don't do too many.  */
 347
 348 bfd_boolean
 349 _bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt)
 350 {
 351   struct ar_cache *cache;
 352   htab_t hash_table = bfd_ardata (arch_bfd)->cache;
 353
 354   /* If the hash table hasn't been created, create it.  */
 355   if (hash_table == NULL)
 356     {
 357       hash_table = htab_create_alloc (16, hash_file_ptr, eq_file_ptr,
 358                                       NULL, _bfd_calloc_wrapper, free);
 359       if (hash_table == NULL)
 360         return FALSE;
 361       bfd_ardata (arch_bfd)->cache = hash_table;
 362     }
 363
 364   /* Insert new_elt into the hash table by filepos.  */
 365   cache = (struct ar_cache *) bfd_zalloc (arch_bfd, sizeof (struct ar_cache));
 366   cache->ptr = filepos;
 367   cache->arbfd = new_elt;
 368   *htab_find_slot (hash_table, (const void *) cache, INSERT) = cache;
 369
 370   /* Provide a means of accessing this from child.  */
 371   arch_eltdata (new_elt)->parent_cache = hash_table;
 372   arch_eltdata (new_elt)->key = filepos;
 373
 374   return TRUE;
 375 }
 376 \f
 377 static bfd *
 378 _bfd_find_nested_archive (bfd *arch_bfd, const char *filename)
 379 {
 380   bfd *abfd;
 381   const char *target;
 382
 383   /* PR 15140: Don't allow a nested archive pointing to itself.  */
 384   if (filename_cmp (filename, arch_bfd->filename) == 0)
 385     {
 386       bfd_set_error (bfd_error_malformed_archive);
 387       return NULL;
 388     }
 389
 390   for (abfd = arch_bfd->nested_archives;
 391        abfd != NULL;
 392        abfd = abfd->archive_next)
 393     {
 394       if (filename_cmp (filename, abfd->filename) == 0)
 395         return abfd;
 396     }
 397   target = NULL;
 398   if (!arch_bfd->target_defaulted)
 399     target = arch_bfd->xvec->name;
 400   abfd = bfd_openr (filename, target);
 401   if (abfd)
 402     {
 403       abfd->archive_next = arch_bfd->nested_archives;
 404       arch_bfd->nested_archives = abfd;
 405     }
 406   return abfd;
 407 }
 408
 409 /* The name begins with space.  Hence the rest of the name is an index into
 410    the string table.  */
 411
 412 static char *
 413 get_extended_arelt_filename (bfd *arch, const char *name, file_ptr *originp)
 414 {
 415   unsigned long table_index = 0;
 416   const char *endp;
 417
 418   /* Should extract string so that I can guarantee not to overflow into
 419      the next region, but I'm too lazy.  */
 420   errno = 0;
 421   /* Skip first char, which is '/' in SVR4 or ' ' in some other variants.  */
 422   table_index = strtol (name + 1, (char **) &endp, 10);
 423   if (errno != 0 || table_index >= bfd_ardata (arch)->extended_names_size)
 424     {
 425       bfd_set_error (bfd_error_malformed_archive);
 426       return NULL;
 427     }
 428   /* In a thin archive, a member of an archive-within-an-archive
 429      will have the offset in the inner archive encoded here.  */
 430   if (bfd_is_thin_archive (arch) && endp != NULL && *endp == ':')
 431     {
 432       file_ptr origin = strtol (endp + 1, NULL, 10);
 433
 434       if (errno != 0)
 435         {
 436           bfd_set_error (bfd_error_malformed_archive);
 437           return NULL;
 438         }
 439       *originp = origin;
 440     }
 441   else
 442     *originp = 0;
 443
 444   return bfd_ardata (arch)->extended_names + table_index;
 445 }
 446
 447 /* This functions reads an arch header and returns an areltdata pointer, or
 448    NULL on error.
 449
 450    Presumes the file pointer is already in the right place (ie pointing
 451    to the ar_hdr in the file).   Moves the file pointer; on success it
 452    should be pointing to the front of the file contents; on failure it
 453    could have been moved arbitrarily.  */
 454
 455 void *
 456 _bfd_generic_read_ar_hdr (bfd *abfd)
 457 {
 458   return _bfd_generic_read_ar_hdr_mag (abfd, NULL);
 459 }
 460
 461 /* Alpha ECOFF uses an optional different ARFMAG value, so we have a
 462    variant of _bfd_generic_read_ar_hdr which accepts a magic string.  */
 463
 464 void *
 465 _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
 466 {
 467   struct ar_hdr hdr;
 468   char *hdrp = (char *) &hdr;
 469   bfd_size_type parsed_size;
 470   struct areltdata *ared;
 471   char *filename = NULL;
 472   bfd_size_type namelen = 0;
 473   bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
 474   char *allocptr = 0;
 475   file_ptr origin = 0;
 476   unsigned int extra_size = 0;
 477   char fmag_save;
 478   int scan;
 479
 480   if (bfd_bread (hdrp, sizeof (struct ar_hdr), abfd) != sizeof (struct ar_hdr))
 481     {
 482       if (bfd_get_error () != bfd_error_system_call)
 483         bfd_set_error (bfd_error_no_more_archived_files);
 484       return NULL;
 485     }
 486   if (strncmp (hdr.ar_fmag, ARFMAG, 2) != 0
 487       && (mag == NULL
 488           || strncmp (hdr.ar_fmag, mag, 2) != 0))
 489     {
 490       bfd_set_error (bfd_error_malformed_archive);
 491       return NULL;
 492     }
 493
 494   errno = 0;
 495   fmag_save = hdr.ar_fmag[0];
 496   hdr.ar_fmag[0] = 0;
 497   scan = sscanf (hdr.ar_size, "%" BFD_VMA_FMT "u", &parsed_size);
 498   hdr.ar_fmag[0] = fmag_save;
 499   if (scan != 1)
 500     {
 501       bfd_set_error (bfd_error_malformed_archive);
 502       return NULL;
 503     }
 504
 505   /* Extract the filename from the archive - there are two ways to
 506      specify an extended name table, either the first char of the
 507      name is a space, or it's a slash.  */
 508   if ((hdr.ar_name[0] == '/'
 509        || (hdr.ar_name[0] == ' '
 510            && memchr (hdr.ar_name, '/', ar_maxnamelen (abfd)) == NULL))
 511       && bfd_ardata (abfd)->extended_names != NULL)
 512     {
 513       filename = get_extended_arelt_filename (abfd, hdr.ar_name, &origin);
 514       if (filename == NULL)
 515         return NULL;
 516     }
 517   /* BSD4.4-style long filename.  */
 518   else if (is_bsd44_extended_name (hdr.ar_name))
 519     {
 520       /* BSD-4.4 extended name */
 521       namelen = atoi (&hdr.ar_name[3]);
 522       allocsize += namelen + 1;
 523       parsed_size -= namelen;
 524       extra_size = namelen;
 525
 526       allocptr = (char *) bfd_zmalloc (allocsize);
 527       if (allocptr == NULL)
 528         return NULL;
 529       filename = (allocptr
 530                   + sizeof (struct areltdata)
 531                   + sizeof (struct ar_hdr));
 532       if (bfd_bread (filename, namelen, abfd) != namelen)
 533         {
 534           free (allocptr);
 535           if (bfd_get_error () != bfd_error_system_call)
 536             bfd_set_error (bfd_error_no_more_archived_files);
 537           return NULL;
 538         }
 539       filename[namelen] = '\0';
 540     }
 541   else
 542     {
 543       /* We judge the end of the name by looking for '/' or ' '.
 544          Note:  The SYSV format (terminated by '/') allows embedded
 545          spaces, so only look for ' ' if we don't find '/'.  */
 546
 547       char *e;
 548       e = (char *) memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
 549       if (e == NULL)
 550         {
 551           e = (char *) memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
 552           if (e == NULL)
 553             e = (char *) memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
 554         }
 555
 556       if (e != NULL)
 557         namelen = e - hdr.ar_name;
 558       else
 559         {
 560           /* If we didn't find a termination character, then the name
 561              must be the entire field.  */
 562           namelen = ar_maxnamelen (abfd);
 563         }
 564
 565       allocsize += namelen + 1;
 566     }
 567
 568   if (!allocptr)
 569     {
 570       allocptr = (char *) bfd_zmalloc (allocsize);
 571       if (allocptr == NULL)
 572         return NULL;
 573     }
 574
 575   ared = (struct areltdata *) allocptr;
 576
 577   ared->arch_header = allocptr + sizeof (struct areltdata);
 578   memcpy (ared->arch_header, &hdr, sizeof (struct ar_hdr));
 579   ared->parsed_size = parsed_size;
 580   ared->extra_size = extra_size;
 581   ared->origin = origin;
 582
 583   if (filename != NULL)
 584     ared->filename = filename;
 585   else
 586     {
 587       ared->filename = allocptr + (sizeof (struct areltdata) +
 588                                    sizeof (struct ar_hdr));
 589       if (namelen)
 590         memcpy (ared->filename, hdr.ar_name, namelen);
 591       ared->filename[namelen] = '\0';
 592     }
 593
 594   return ared;
 595 }
 596 \f
 597 /* Append the relative pathname for a member of the thin archive
 598    to the pathname of the directory containing the archive.  */
 599
 600 char *
 601 _bfd_append_relative_path (bfd *arch, char *elt_name)
 602 {
 603   const char *arch_name = arch->filename;
 604   const char *base_name = lbasename (arch_name);
 605   size_t prefix_len;
 606   char *filename;
 607
 608   if (base_name == arch_name)
 609     return elt_name;
 610
 611   prefix_len = base_name - arch_name;
 612   filename = (char *) bfd_alloc (arch, prefix_len + strlen (elt_name) + 1);
 613   if (filename == NULL)
 614     return NULL;
 615
 616   strncpy (filename, arch_name, prefix_len);
 617   strcpy (filename + prefix_len, elt_name);
 618   return filename;
 619 }
 620
 621 /* This is an internal function; it's mainly used when indexing
 622    through the archive symbol table, but also used to get the next
 623    element, since it handles the bookkeeping so nicely for us.  */
 624
 625 bfd *
 626 _bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos)
 627 {
 628   struct areltdata *new_areldata;
 629   bfd *n_nfd;
 630   char *filename;
 631
 632   n_nfd = _bfd_look_for_bfd_in_cache (archive, filepos);
 633   if (n_nfd)
 634     return n_nfd;
 635
 636   if (0 > bfd_seek (archive, filepos, SEEK_SET))
 637     return NULL;
 638
 639   if ((new_areldata = (struct areltdata *) _bfd_read_ar_hdr (archive)) == NULL)
 640     return NULL;
 641
 642   filename = new_areldata->filename;
 643
 644   if (bfd_is_thin_archive (archive))
 645     {
 646       const char *target;
 647
 648       /* This is a proxy entry for an external file.  */
 649       if (! IS_ABSOLUTE_PATH (filename))
 650         {
 651           filename = _bfd_append_relative_path (archive, filename);
 652           if (filename == NULL)
 653             {
 654               free (new_areldata);
 655               return NULL;
 656             }
 657         }
 658
 659       if (new_areldata->origin > 0)
 660         {
 661           /* This proxy entry refers to an element of a nested archive.
 662              Locate the member of that archive and return a bfd for it.  */
 663           bfd *ext_arch = _bfd_find_nested_archive (archive, filename);
 664
 665           if (ext_arch == NULL
 666               || ! bfd_check_format (ext_arch, bfd_archive))
 667             {
 668               free (new_areldata);
 669               return NULL;
 670             }
 671           n_nfd = _bfd_get_elt_at_filepos (ext_arch, new_areldata->origin);
 672           if (n_nfd == NULL)
 673             {
 674               free (new_areldata);
 675               return NULL;
 676             }
 677           n_nfd->proxy_origin = bfd_tell (archive);
 678           return n_nfd;
 679         }
 680       /* It's not an element of a nested archive;
 681          open the external file as a bfd.  */
 682       target = NULL;
 683       if (!archive->target_defaulted)
 684         target = archive->xvec->name;
 685       n_nfd = bfd_openr (filename, target);
 686       if (n_nfd == NULL)
 687         bfd_set_error (bfd_error_malformed_archive);
 688     }
 689   else
 690     {
 691       n_nfd = _bfd_create_empty_archive_element_shell (archive);
 692     }
 693
 694   if (n_nfd == NULL)
 695     {
 696       free (new_areldata);
 697       return NULL;
 698     }
 699
 700   n_nfd->proxy_origin = bfd_tell (archive);
 701
 702   if (bfd_is_thin_archive (archive))
 703     {
 704       n_nfd->origin = 0;
 705     }
 706   else
 707     {
 708       n_nfd->origin = n_nfd->proxy_origin;
 709       n_nfd->filename = xstrdup (filename);
 710     }
 711
 712   n_nfd->arelt_data = new_areldata;
 713
 714   /* Copy BFD_COMPRESS and BFD_DECOMPRESS flags.  */
 715   n_nfd->flags |= archive->flags & (BFD_COMPRESS | BFD_DECOMPRESS);
 716
 717   if (_bfd_add_bfd_to_archive_cache (archive, filepos, n_nfd))
 718     return n_nfd;
 719
 720   free (new_areldata);
 721   n_nfd->arelt_data = NULL;
 722   return NULL;
 723 }
 724
 725 /* Return the BFD which is referenced by the symbol in ABFD indexed by
 726    SYM_INDEX.  SYM_INDEX should have been returned by bfd_get_next_mapent.  */
 727
 728 bfd *
 729 _bfd_generic_get_elt_at_index (bfd *abfd, symindex sym_index)
 730 {
 731   carsym *entry;
 732
 733   entry = bfd_ardata (abfd)->symdefs + sym_index;
 734   return _bfd_get_elt_at_filepos (abfd, entry->file_offset);
 735 }
 736
 737 /*
 738 FUNCTION
 739         bfd_openr_next_archived_file
 740
 741 SYNOPSIS
 742         bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous);
 743
 744 DESCRIPTION
 745         Provided a BFD, @var{archive}, containing an archive and NULL, open
 746         an input BFD on the first contained element and returns that.
 747         Subsequent calls should pass
 748         the archive and the previous return value to return a created
 749         BFD to the next contained element. NULL is returned when there
 750         are no more.
 751 */
 752
 753 bfd *
 754 bfd_openr_next_archived_file (bfd *archive, bfd *last_file)
 755 {
 756   if ((bfd_get_format (archive) != bfd_archive)
 757       || (archive->direction == write_direction))
 758     {
 759       bfd_set_error (bfd_error_invalid_operation);
 760       return NULL;
 761     }
 762
 763   return BFD_SEND (archive,
 764                    openr_next_archived_file, (archive, last_file));
 765 }
 766
 767 bfd *
 768 bfd_generic_openr_next_archived_file (bfd *archive, bfd *last_file)
 769 {
 770   file_ptr filestart;
 771
 772   if (!last_file)
 773     filestart = bfd_ardata (archive)->first_file_filepos;
 774   else
 775     {
 776       bfd_size_type size = arelt_size (last_file);
 777
 778       filestart = last_file->proxy_origin;
 779       if (! bfd_is_thin_archive (archive))
 780         filestart += size;
 781       /* Pad to an even boundary...
 782          Note that last_file->origin can be odd in the case of
 783          BSD-4.4-style element with a long odd size.  */
 784       filestart += filestart % 2;
 785     }
 786
 787   return _bfd_get_elt_at_filepos (archive, filestart);
 788 }
 789
 790 const bfd_target *
 791 bfd_generic_archive_p (bfd *abfd)
 792 {
 793   struct artdata *tdata_hold;
 794   char armag[SARMAG + 1];
 795   bfd_size_type amt;
 796
 797   if (bfd_bread (armag, SARMAG, abfd) != SARMAG)
 798     {
 799       if (bfd_get_error () != bfd_error_system_call)
 800         bfd_set_error (bfd_error_wrong_format);
 801       return NULL;
 802     }
 803
 804   bfd_is_thin_archive (abfd) = (strncmp (armag, ARMAGT, SARMAG) == 0);
 805
 806   if (strncmp (armag, ARMAG, SARMAG) != 0
 807       && strncmp (armag, ARMAGB, SARMAG) != 0
 808       && ! bfd_is_thin_archive (abfd))
 809     return NULL;
 810
 811   tdata_hold = bfd_ardata (abfd);
 812
 813   amt = sizeof (struct artdata);
 814   bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
 815   if (bfd_ardata (abfd) == NULL)
 816     {
 817       bfd_ardata (abfd) = tdata_hold;
 818       return NULL;
 819     }
 820
 821   bfd_ardata (abfd)->first_file_filepos = SARMAG;
 822   /* Cleared by bfd_zalloc above.
 823      bfd_ardata (abfd)->cache = NULL;
 824      bfd_ardata (abfd)->archive_head = NULL;
 825      bfd_ardata (abfd)->symdefs = NULL;
 826      bfd_ardata (abfd)->extended_names = NULL;
 827      bfd_ardata (abfd)->extended_names_size = 0;
 828      bfd_ardata (abfd)->tdata = NULL;  */
 829
 830   if (!BFD_SEND (abfd, _bfd_slurp_armap, (abfd))
 831       || !BFD_SEND (abfd, _bfd_slurp_extended_name_table, (abfd)))
 832     {
 833       if (bfd_get_error () != bfd_error_system_call)
 834         bfd_set_error (bfd_error_wrong_format);
 835       bfd_release (abfd, bfd_ardata (abfd));
 836       bfd_ardata (abfd) = tdata_hold;
 837       return NULL;
 838     }
 839
 840   if (abfd->target_defaulted && bfd_has_map (abfd))
 841     {
 842       bfd *first;
 843
 844       /* This archive has a map, so we may presume that the contents
 845          are object files.  Make sure that if the first file in the
 846          archive can be recognized as an object file, it is for this
 847          target.  If not, assume that this is the wrong format.  If
 848          the first file is not an object file, somebody is doing
 849          something weird, and we permit it so that ar -t will work.
 850
 851          This is done because any normal format will recognize any
 852          normal archive, regardless of the format of the object files.
 853          We do accept an empty archive.  */
 854
 855       first = bfd_openr_next_archived_file (abfd, NULL);
 856       if (first != NULL)
 857         {
 858           first->target_defaulted = FALSE;
 859           if (bfd_check_format (first, bfd_object)
 860               && first->xvec != abfd->xvec)
 861             bfd_set_error (bfd_error_wrong_object_format);
 862           /* And we ought to close `first' here too.  */
 863         }
 864     }
 865
 866   return abfd->xvec;
 867 }
 868
 869 /* Some constants for a 32 bit BSD archive structure.  We do not
 870    support 64 bit archives presently; so far as I know, none actually
 871    exist.  Supporting them would require changing these constants, and
 872    changing some H_GET_32 to H_GET_64.  */
 873
 874 /* The size of an external symdef structure.  */
 875 #define BSD_SYMDEF_SIZE 8
 876
 877 /* The offset from the start of a symdef structure to the file offset.  */
 878 #define BSD_SYMDEF_OFFSET_SIZE 4
 879
 880 /* The size of the symdef count.  */
 881 #define BSD_SYMDEF_COUNT_SIZE 4
 882
 883 /* The size of the string count.  */
 884 #define BSD_STRING_COUNT_SIZE 4
 885
 886 /* Read a BSD-style archive symbol table.  Returns FALSE on error,
 887    TRUE otherwise.  */
 888
 889 static bfd_boolean
 890 do_slurp_bsd_armap (bfd *abfd)
 891 {
 892   struct areltdata *mapdata;
 893   unsigned int counter;
 894   bfd_byte *raw_armap, *rbase;
 895   struct artdata *ardata = bfd_ardata (abfd);
 896   char *stringbase;
 897   bfd_size_type parsed_size, amt;
 898   carsym *set;
 899
 900   mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
 901   if (mapdata == NULL)
 902     return FALSE;
 903   parsed_size = mapdata->parsed_size;
 904   free (mapdata);
 905
 906   raw_armap = (bfd_byte *) bfd_zalloc (abfd, parsed_size);
 907   if (raw_armap == NULL)
 908     return FALSE;
 909
 910   if (bfd_bread (raw_armap, parsed_size, abfd) != parsed_size)
 911     {
 912       if (bfd_get_error () != bfd_error_system_call)
 913         bfd_set_error (bfd_error_malformed_archive);
 914     byebye:
 915       bfd_release (abfd, raw_armap);
 916       return FALSE;
 917     }
 918
 919   ardata->symdef_count = H_GET_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE;
 920
 921   if (ardata->symdef_count * BSD_SYMDEF_SIZE >
 922       parsed_size - BSD_SYMDEF_COUNT_SIZE)
 923     {
 924       /* Probably we're using the wrong byte ordering.  */
 925       bfd_set_error (bfd_error_wrong_format);
 926       goto byebye;
 927     }
 928
 929   ardata->cache = 0;
 930   rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE;
 931   stringbase = ((char *) rbase
 932                 + ardata->symdef_count * BSD_SYMDEF_SIZE
 933                 + BSD_STRING_COUNT_SIZE);
 934   amt = ardata->symdef_count * sizeof (carsym);
 935   ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt);
 936   if (!ardata->symdefs)
 937     return FALSE;
 938
 939   for (counter = 0, set = ardata->symdefs;
 940        counter < ardata->symdef_count;
 941        counter++, set++, rbase += BSD_SYMDEF_SIZE)
 942     {
 943       set->name = H_GET_32 (abfd, rbase) + stringbase;
 944       set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
 945     }
 946
 947   ardata->first_file_filepos = bfd_tell (abfd);
 948   /* Pad to an even boundary if you have to.  */
 949   ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
 950   /* FIXME, we should provide some way to free raw_ardata when
 951      we are done using the strings from it.  For now, it seems
 952      to be allocated on an objalloc anyway...  */
 953   bfd_has_map (abfd) = TRUE;
 954   return TRUE;
 955 }
 956
 957 /* Read a COFF archive symbol table.  Returns FALSE on error, TRUE
 958    otherwise.  */
 959
 960 static bfd_boolean
 961 do_slurp_coff_armap (bfd *abfd)
 962 {
 963   struct areltdata *mapdata;
 964   int *raw_armap, *rawptr;
 965   struct artdata *ardata = bfd_ardata (abfd);
 966   char *stringbase;
 967   bfd_size_type stringsize;
 968   bfd_size_type parsed_size;
 969   carsym *carsyms;
 970   bfd_size_type nsymz;          /* Number of symbols in armap.  */
 971   bfd_vma (*swap) (const void *);
 972   char int_buf[sizeof (long)];
 973   bfd_size_type carsym_size, ptrsize;
 974   unsigned int i;
 975
 976   mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
 977   if (mapdata == NULL)
 978     return FALSE;
 979   parsed_size = mapdata->parsed_size;
 980   free (mapdata);
 981
 982   if (bfd_bread (int_buf, 4, abfd) != 4)
 983     {
 984       if (bfd_get_error () != bfd_error_system_call)
 985         bfd_set_error (bfd_error_malformed_archive);
 986       return FALSE;
 987     }
 988   /* It seems that all numeric information in a coff archive is always
 989      in big endian format, nomatter the host or target.  */
 990   swap = bfd_getb32;
 991   nsymz = bfd_getb32 (int_buf);
 992   stringsize = parsed_size - (4 * nsymz) - 4;
 993
 994   /* ... except that some archive formats are broken, and it may be our
 995      fault - the i960 little endian coff sometimes has big and sometimes
 996      little, because our tools changed.  Here's a horrible hack to clean
 997      up the crap.  */
 998
 999   if (stringsize > 0xfffff
1000       && bfd_get_arch (abfd) == bfd_arch_i960
1001       && bfd_get_flavour (abfd) == bfd_target_coff_flavour)
1002     {
1003       /* This looks dangerous, let's do it the other way around.  */
1004       nsymz = bfd_getl32 (int_buf);
1005       stringsize = parsed_size - (4 * nsymz) - 4;
1006       swap = bfd_getl32;
1007     }
1008
1009   /* The coff armap must be read sequentially.  So we construct a
1010      bsd-style one in core all at once, for simplicity.  */
1011
1012   if (nsymz > ~ (bfd_size_type) 0 / sizeof (carsym))
1013     return FALSE;
1014
1015   carsym_size = (nsymz * sizeof (carsym));
1016   ptrsize = (4 * nsymz);
1017
1018   if (carsym_size + stringsize + 1 <= carsym_size)
1019     return FALSE;
1020
1021   ardata->symdefs = (struct carsym *) bfd_zalloc (abfd,
1022                                                   carsym_size + stringsize + 1);
1023   if (ardata->symdefs == NULL)
1024     return FALSE;
1025   carsyms = ardata->symdefs;
1026   stringbase = ((char *) ardata->symdefs) + carsym_size;
1027
1028   /* Allocate and read in the raw offsets.  */
1029   raw_armap = (int *) bfd_alloc (abfd, ptrsize);
1030   if (raw_armap == NULL)
1031     goto release_symdefs;
1032   if (bfd_bread (raw_armap, ptrsize, abfd) != ptrsize
1033       || (bfd_bread (stringbase, stringsize, abfd) != stringsize))
1034     {
1035       if (bfd_get_error () != bfd_error_system_call)
1036         bfd_set_error (bfd_error_malformed_archive);
1037       goto release_raw_armap;
1038     }
1039
1040   /* OK, build the carsyms.  */
1041   for (i = 0; i < nsymz; i++)
1042     {
1043       rawptr = raw_armap + i;
1044       carsyms->file_offset = swap ((bfd_byte *) rawptr);
1045       carsyms->name = stringbase;
1046       stringbase += strlen (stringbase) + 1;
1047       carsyms++;
1048     }
1049   *stringbase = 0;
1050
1051   ardata->symdef_count = nsymz;
1052   ardata->first_file_filepos = bfd_tell (abfd);
1053   /* Pad to an even boundary if you have to.  */
1054   ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1055
1056   bfd_has_map (abfd) = TRUE;
1057   bfd_release (abfd, raw_armap);
1058
1059   /* Check for a second archive header (as used by PE).  */
1060   {
1061     struct areltdata *tmp;
1062
1063     bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET);
1064     tmp = (struct areltdata *) _bfd_read_ar_hdr (abfd);
1065     if (tmp != NULL)
1066       {
1067         if (tmp->arch_header[0] == '/'
1068             && tmp->arch_header[1] == ' ')
1069           {
1070             ardata->first_file_filepos +=
1071               (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1;
1072           }
1073         free (tmp);
1074       }
1075   }
1076
1077   return TRUE;
1078
1079 release_raw_armap:
1080   bfd_release (abfd, raw_armap);
1081 release_symdefs:
1082   bfd_release (abfd, (ardata)->symdefs);
1083   return FALSE;
1084 }
1085
1086 /* This routine can handle either coff-style or bsd-style armaps
1087    (archive symbol table).  Returns FALSE on error, TRUE otherwise */
1088
1089 bfd_boolean
1090 bfd_slurp_armap (bfd *abfd)
1091 {
1092   char nextname[17];
1093   int i = bfd_bread (nextname, 16, abfd);
1094
1095   if (i == 0)
1096     return TRUE;
1097   if (i != 16)
1098     return FALSE;
1099
1100   if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1101     return FALSE;
1102
1103   if (CONST_STRNEQ (nextname, "__.SYMDEF       ")
1104       || CONST_STRNEQ (nextname, "__.SYMDEF/      ")) /* Old Linux archives.  */
1105     return do_slurp_bsd_armap (abfd);
1106   else if (CONST_STRNEQ (nextname, "/               "))
1107     return do_slurp_coff_armap (abfd);
1108   else if (CONST_STRNEQ (nextname, "/SYM64/         "))
1109     {
1110       /* 64bit ELF (Irix 6) archive.  */
1111 #ifdef BFD64
1112       extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *);
1113       return bfd_elf64_archive_slurp_armap (abfd);
1114 #else
1115       bfd_set_error (bfd_error_wrong_format);
1116       return FALSE;
1117 #endif
1118     }
1119   else if (CONST_STRNEQ (nextname, "#1/20           "))
1120     {
1121       /* Mach-O has a special name for armap when the map is sorted by name.
1122          However because this name has a space it is slightly more difficult
1123          to check it.  */
1124       struct ar_hdr hdr;
1125       char extname[21];
1126
1127       if (bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
1128         return FALSE;
1129       /* Read the extended name.  We know its length.  */
1130       if (bfd_bread (extname, 20, abfd) != 20)
1131         return FALSE;
1132       if (bfd_seek (abfd, -(file_ptr) (sizeof (hdr) + 20), SEEK_CUR) != 0)
1133         return FALSE;
1134       if (CONST_STRNEQ (extname, "__.SYMDEF SORTED")
1135           || CONST_STRNEQ (extname, "__.SYMDEF"))
1136         return do_slurp_bsd_armap (abfd);
1137     }
1138
1139   bfd_has_map (abfd) = FALSE;
1140   return TRUE;
1141 }
1142 \f
1143 /* Returns FALSE on error, TRUE otherwise.  */
1144 /* Flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
1145    header is in a slightly different order and the map name is '/'.
1146    This flavour is used by hp300hpux.  */
1147
1148 #define HPUX_SYMDEF_COUNT_SIZE 2
1149
1150 bfd_boolean
1151 bfd_slurp_bsd_armap_f2 (bfd *abfd)
1152 {
1153   struct areltdata *mapdata;
1154   char nextname[17];
1155   unsigned int counter;
1156   bfd_byte *raw_armap, *rbase;
1157   struct artdata *ardata = bfd_ardata (abfd);
1158   char *stringbase;
1159   unsigned int stringsize;
1160   unsigned int left;
1161   bfd_size_type amt;
1162   carsym *set;
1163   int i = bfd_bread (nextname, 16, abfd);
1164
1165   if (i == 0)
1166     return TRUE;
1167   if (i != 16)
1168     return FALSE;
1169
1170   /* The archive has at least 16 bytes in it.  */
1171   if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1172     return FALSE;
1173
1174   if (CONST_STRNEQ (nextname, "__.SYMDEF       ")
1175       || CONST_STRNEQ (nextname, "__.SYMDEF/      ")) /* Old Linux archives.  */
1176     return do_slurp_bsd_armap (abfd);
1177
1178   if (! CONST_STRNEQ (nextname, "/               "))
1179     {
1180       bfd_has_map (abfd) = FALSE;
1181       return TRUE;
1182     }
1183
1184   mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
1185   if (mapdata == NULL)
1186     return FALSE;
1187
1188   if (mapdata->parsed_size < HPUX_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE)
1189     {
1190       free (mapdata);
1191     wrong_format:
1192       bfd_set_error (bfd_error_wrong_format);
1193     byebye:
1194       return FALSE;
1195     }
1196   left = mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE - BSD_STRING_COUNT_SIZE;
1197
1198   amt = mapdata->parsed_size;
1199   free (mapdata);
1200
1201   raw_armap = (bfd_byte *) bfd_zalloc (abfd, amt);
1202   if (raw_armap == NULL)
1203     goto byebye;
1204
1205   if (bfd_bread (raw_armap, amt, abfd) != amt)
1206     {
1207       if (bfd_get_error () != bfd_error_system_call)
1208         bfd_set_error (bfd_error_malformed_archive);
1209       goto byebye;
1210     }
1211
1212   ardata->symdef_count = H_GET_16 (abfd, raw_armap);
1213
1214   ardata->cache = 0;
1215
1216   stringsize = H_GET_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE);
1217   if (stringsize > left)
1218     goto wrong_format;
1219   left -= stringsize;
1220
1221   /* Skip sym count and string sz.  */
1222   stringbase = ((char *) raw_armap
1223                 + HPUX_SYMDEF_COUNT_SIZE
1224                 + BSD_STRING_COUNT_SIZE);
1225   rbase = (bfd_byte *) stringbase + stringsize;
1226   amt = ardata->symdef_count * BSD_SYMDEF_SIZE;
1227   if (amt > left)
1228     goto wrong_format;
1229
1230   ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt);
1231   if (!ardata->symdefs)
1232     return FALSE;
1233
1234   for (counter = 0, set = ardata->symdefs;
1235        counter < ardata->symdef_count;
1236        counter++, set++, rbase += BSD_SYMDEF_SIZE)
1237     {
1238       set->name = H_GET_32 (abfd, rbase) + stringbase;
1239       set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
1240     }
1241
1242   ardata->first_file_filepos = bfd_tell (abfd);
1243   /* Pad to an even boundary if you have to.  */
1244   ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1245   /* FIXME, we should provide some way to free raw_ardata when
1246      we are done using the strings from it.  For now, it seems
1247      to be allocated on an objalloc anyway...  */
1248   bfd_has_map (abfd) = TRUE;
1249   return TRUE;
1250 }
1251 \f
1252 /** Extended name table.
1253
1254   Normally archives support only 14-character filenames.
1255
1256   Intel has extended the format: longer names are stored in a special
1257   element (the first in the archive, or second if there is an armap);
1258   the name in the ar_hdr is replaced by <space><index into filename
1259   element>.  Index is the P.R. of an int (decimal).  Data General have
1260   extended the format by using the prefix // for the special element.  */
1261
1262 /* Returns FALSE on error, TRUE otherwise.  */
1263
1264 bfd_boolean
1265 _bfd_slurp_extended_name_table (bfd *abfd)
1266 {
1267   char nextname[17];
1268   struct areltdata *namedata;
1269   bfd_size_type amt;
1270
1271   /* FIXME:  Formatting sucks here, and in case of failure of BFD_READ,
1272      we probably don't want to return TRUE.  */
1273   if (bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET) != 0)
1274     return FALSE;
1275
1276   if (bfd_bread (nextname, 16, abfd) == 16)
1277     {
1278       if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1279         return FALSE;
1280
1281       if (! CONST_STRNEQ (nextname, "ARFILENAMES/    ")
1282           && ! CONST_STRNEQ (nextname, "//              "))
1283         {
1284           bfd_ardata (abfd)->extended_names = NULL;
1285           bfd_ardata (abfd)->extended_names_size = 0;
1286           return TRUE;
1287         }
1288
1289       namedata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
1290       if (namedata == NULL)
1291         return FALSE;
1292
1293       amt = namedata->parsed_size;
1294       if (amt + 1 == 0)
1295         goto byebye;
1296       /* PR binutils/17533: A corrupt archive can contain an invalid size.  */
1297       if (amt > (bfd_size_type) bfd_get_size (abfd))
1298         goto byebye;
1299
1300       bfd_ardata (abfd)->extended_names_size = amt;
1301       bfd_ardata (abfd)->extended_names = (char *) bfd_zalloc (abfd, amt + 1);
1302       if (bfd_ardata (abfd)->extended_names == NULL)
1303         {
1304         byebye:
1305           free (namedata);
1306           bfd_ardata (abfd)->extended_names = NULL;
1307           bfd_ardata (abfd)->extended_names_size = 0;
1308           return FALSE;
1309         }
1310
1311       if (bfd_bread (bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
1312         {
1313           if (bfd_get_error () != bfd_error_system_call)
1314             bfd_set_error (bfd_error_malformed_archive);
1315           bfd_release (abfd, (bfd_ardata (abfd)->extended_names));
1316           goto byebye;
1317         }
1318
1319       /* Since the archive is supposed to be printable if it contains
1320          text, the entries in the list are newline-padded, not null
1321          padded. In SVR4-style archives, the names also have a
1322          trailing '/'.  DOS/NT created archive often have \ in them
1323          We'll fix all problems here.  */
1324       {
1325         char *ext_names = bfd_ardata (abfd)->extended_names;
1326         char *temp = ext_names;
1327         char *limit = temp + namedata->parsed_size;
1328
1329         for (; temp < limit; ++temp)
1330           {
1331             if (*temp == ARFMAG[1])
1332               temp[temp > ext_names && temp[-1] == '/' ? -1 : 0] = '\0';
1333             if (*temp == '\\')
1334               *temp = '/';
1335           }
1336         *limit = '\0';
1337       }
1338
1339       /* Pad to an even boundary if you have to.  */
1340       bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd);
1341       bfd_ardata (abfd)->first_file_filepos +=
1342         (bfd_ardata (abfd)->first_file_filepos) % 2;
1343
1344       free (namedata);
1345     }
1346   return TRUE;
1347 }
1348
1349 #ifdef VMS
1350
1351 /* Return a copy of the stuff in the filename between any :]> and a
1352    semicolon.  */
1353
1354 static const char *
1355 normalize (bfd *abfd, const char *file)
1356 {
1357   const char *first;
1358   const char *last;
1359   char *copy;
1360
1361   first = file + strlen (file) - 1;
1362   last = first + 1;
1363
1364   while (first != file)
1365     {
1366       if (*first == ';')
1367         last = first;
1368       if (*first == ':' || *first == ']' || *first == '>')
1369         {
1370           first++;
1371           break;
1372         }
1373       first--;
1374     }
1375
1376   copy = bfd_alloc (abfd, last - first + 1);
1377   if (copy == NULL)
1378     return NULL;
1379
1380   memcpy (copy, first, last - first);
1381   copy[last - first] = 0;
1382
1383   return copy;
1384 }
1385
1386 #else
1387 static const char *
1388 normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file)
1389 {
1390   return lbasename (file);
1391 }
1392 #endif
1393
1394 /* Adjust a relative path name based on the reference path.
1395    For example:
1396
1397      Relative path  Reference path  Result
1398      -------------  --------------  ------
1399      bar.o          lib.a           bar.o
1400      foo/bar.o      lib.a           foo/bar.o
1401      bar.o          foo/lib.a       ../bar.o
1402      foo/bar.o      baz/lib.a       ../foo/bar.o
1403      bar.o          ../lib.a        <parent of current dir>/bar.o
1404    ; ../bar.o       ../lib.a        bar.o
1405    ; ../bar.o       lib.a           ../bar.o
1406      foo/bar.o      ../lib.a        <parent of current dir>/foo/bar.o
1407      bar.o          ../../lib.a     <grandparent>/<parent>/bar.o
1408      bar.o          foo/baz/lib.a   ../../bar.o
1409
1410    Note - the semicolons above are there to prevent the BFD chew
1411    utility from interpreting those lines as prototypes to put into
1412    the autogenerated bfd.h header...
1413
1414    Note - the string is returned in a static buffer.  */
1415
1416 static const char *
1417 adjust_relative_path (const char * path, const char * ref_path)
1418 {
1419   static char *pathbuf = NULL;
1420   static unsigned int pathbuf_len = 0;
1421   const char *pathp;
1422   const char *refp;
1423   char * lpath;
1424   char * rpath;
1425   unsigned int len;
1426   unsigned int dir_up = 0;
1427   unsigned int dir_down = 0;
1428   char *newp;
1429   char * pwd = getpwd ();
1430   const char * down;
1431
1432   /* Remove symlinks, '.' and '..' from the paths, if possible.  */
1433   lpath = lrealpath (path);
1434   pathp = lpath == NULL ? path : lpath;
1435
1436   rpath = lrealpath (ref_path);
1437   refp = rpath == NULL ? ref_path : rpath;
1438
1439   /* Remove common leading path elements.  */
1440   for (;;)
1441     {
1442       const char *e1 = pathp;
1443       const char *e2 = refp;
1444
1445       while (*e1 && ! IS_DIR_SEPARATOR (*e1))
1446         ++e1;
1447       while (*e2 && ! IS_DIR_SEPARATOR (*e2))
1448         ++e2;
1449       if (*e1 == '\0' || *e2 == '\0' || e1 - pathp != e2 - refp
1450           || filename_ncmp (pathp, refp, e1 - pathp) != 0)
1451         break;
1452       pathp = e1 + 1;
1453       refp = e2 + 1;
1454     }
1455
1456   len = strlen (pathp) + 1;
1457   /* For each leading path element in the reference path,
1458      insert "../" into the path.  */
1459   for (; *refp; ++refp)
1460     if (IS_DIR_SEPARATOR (*refp))
1461       {
1462         /* PR 12710:  If the path element is "../" then instead of
1463            inserting "../" we need to insert the name of the directory
1464            at the current level.  */
1465         if (refp > ref_path + 1
1466             && refp[-1] == '.'
1467             && refp[-2] == '.')
1468           dir_down ++;
1469         else
1470           dir_up ++;
1471       }
1472
1473   /* If the lrealpath calls above succeeded then we should never
1474      see dir_up and dir_down both being non-zero.  */
1475
1476   len += 3 * dir_up;
1477
1478   if (dir_down)
1479     {
1480       down = pwd + strlen (pwd) - 1;
1481
1482       while (dir_down && down > pwd)
1483         {
1484           if (IS_DIR_SEPARATOR (*down))
1485             --dir_down;
1486         }
1487       BFD_ASSERT (dir_down == 0);
1488       len += strlen (down) + 1;
1489     }
1490   else
1491     down = NULL;
1492
1493   if (len > pathbuf_len)
1494     {
1495       if (pathbuf != NULL)
1496         free (pathbuf);
1497       pathbuf_len = 0;
1498       pathbuf = (char *) bfd_malloc (len);
1499       if (pathbuf == NULL)
1500         goto out;
1501       pathbuf_len = len;
1502     }
1503
1504   newp = pathbuf;
1505   while (dir_up-- > 0)
1506     {
1507       /* FIXME: Support Windows style path separators as well.  */
1508       strcpy (newp, "../");
1509       newp += 3;
1510     }
1511
1512   if (down)
1513     sprintf (newp, "%s/%s", down, pathp);
1514   else
1515     strcpy (newp, pathp);
1516
1517  out:
1518   free (lpath);
1519   free (rpath);
1520   return pathbuf;
1521 }
1522
1523 /* Build a BFD style extended name table.  */
1524
1525 bfd_boolean
1526 _bfd_archive_bsd_construct_extended_name_table (bfd *abfd,
1527                                                 char **tabloc,
1528                                                 bfd_size_type *tablen,
1529                                                 const char **name)
1530 {
1531   *name = "ARFILENAMES/";
1532   return _bfd_construct_extended_name_table (abfd, FALSE, tabloc, tablen);
1533 }
1534
1535 /* Build an SVR4 style extended name table.  */
1536
1537 bfd_boolean
1538 _bfd_archive_coff_construct_extended_name_table (bfd *abfd,
1539                                                  char **tabloc,
1540                                                  bfd_size_type *tablen,
1541                                                  const char **name)
1542 {
1543   *name = "//";
1544   return _bfd_construct_extended_name_table (abfd, TRUE, tabloc, tablen);
1545 }
1546
1547 /* Follows archive_head and produces an extended name table if
1548    necessary.  Returns (in tabloc) a pointer to an extended name
1549    table, and in tablen the length of the table.  If it makes an entry
1550    it clobbers the filename so that the element may be written without
1551    further massage.  Returns TRUE if it ran successfully, FALSE if
1552    something went wrong.  A successful return may still involve a
1553    zero-length tablen!  */
1554
1555 bfd_boolean
1556 _bfd_construct_extended_name_table (bfd *abfd,
1557                                     bfd_boolean trailing_slash,
1558                                     char **tabloc,
1559                                     bfd_size_type *tablen)
1560 {
1561   unsigned int maxname = ar_maxnamelen (abfd);
1562   bfd_size_type total_namelen = 0;
1563   bfd *current;
1564   char *strptr;
1565   const char *last_filename;
1566   long last_stroff;
1567
1568   *tablen = 0;
1569   last_filename = NULL;
1570
1571   /* Figure out how long the table should be.  */
1572   for (current = abfd->archive_head;
1573        current != NULL;
1574        current = current->archive_next)
1575     {
1576       const char *normal;
1577       unsigned int thislen;
1578
1579       if (bfd_is_thin_archive (abfd))
1580         {
1581           const char *filename = current->filename;
1582
1583           /* If the element being added is a member of another archive
1584              (i.e., we are flattening), use the containing archive's name.  */
1585           if (current->my_archive
1586               && ! bfd_is_thin_archive (current->my_archive))
1587             filename = current->my_archive->filename;
1588
1589           /* If the path is the same as the previous path seen,
1590              reuse it.  This can happen when flattening a thin
1591              archive that contains other archives.  */
1592           if (last_filename && filename_cmp (last_filename, filename) == 0)
1593             continue;
1594
1595           last_filename = filename;
1596
1597           /* If the path is relative, adjust it relative to
1598              the containing archive. */
1599           if (! IS_ABSOLUTE_PATH (filename)
1600               && ! IS_ABSOLUTE_PATH (abfd->filename))
1601             normal = adjust_relative_path (filename, abfd->filename);
1602           else
1603             normal = filename;
1604
1605           /* In a thin archive, always store the full pathname
1606              in the extended name table.  */
1607           total_namelen += strlen (normal) + 1;
1608           if (trailing_slash)
1609             /* Leave room for trailing slash.  */
1610             ++total_namelen;
1611
1612           continue;
1613         }
1614
1615       normal = normalize (current, current->filename);
1616       if (normal == NULL)
1617         return FALSE;
1618
1619       thislen = strlen (normal);
1620
1621       if (thislen > maxname
1622           && (bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1623         thislen = maxname;
1624
1625       if (thislen > maxname)
1626         {
1627           /* Add one to leave room for \n.  */
1628           total_namelen += thislen + 1;
1629           if (trailing_slash)
1630             {
1631               /* Leave room for trailing slash.  */
1632               ++total_namelen;
1633             }
1634         }
1635       else
1636         {
1637           struct ar_hdr *hdr = arch_hdr (current);
1638           if (filename_ncmp (normal, hdr->ar_name, thislen) != 0
1639               || (thislen < sizeof hdr->ar_name
1640                   && hdr->ar_name[thislen] != ar_padchar (current)))
1641             {
1642               /* Must have been using extended format even though it
1643                  didn't need to.  Fix it to use normal format.  */
1644               memcpy (hdr->ar_name, normal, thislen);
1645               if (thislen < maxname
1646                   || (thislen == maxname && thislen < sizeof hdr->ar_name))
1647                 hdr->ar_name[thislen] = ar_padchar (current);
1648             }
1649         }
1650     }
1651
1652   if (total_namelen == 0)
1653     return TRUE;
1654
1655   *tabloc = (char *) bfd_zalloc (abfd, total_namelen);
1656   if (*tabloc == NULL)
1657     return FALSE;
1658
1659   *tablen = total_namelen;
1660   strptr = *tabloc;
1661
1662   last_filename = NULL;
1663   last_stroff = 0;
1664
1665   for (current = abfd->archive_head;
1666        current != NULL;
1667        current = current->archive_next)
1668     {
1669       const char *normal;
1670       unsigned int thislen;
1671       long stroff;
1672       const char *filename = current->filename;
1673
1674       if (bfd_is_thin_archive (abfd))
1675         {
1676           /* If the element being added is a member of another archive
1677              (i.e., we are flattening), use the containing archive's name.  */
1678           if (current->my_archive
1679               && ! bfd_is_thin_archive (current->my_archive))
1680             filename = current->my_archive->filename;
1681           /* If the path is the same as the previous path seen,
1682              reuse it.  This can happen when flattening a thin
1683              archive that contains other archives.
1684              If the path is relative, adjust it relative to
1685              the containing archive.  */
1686           if (last_filename && filename_cmp (last_filename, filename) == 0)
1687             normal = last_filename;
1688           else if (! IS_ABSOLUTE_PATH (filename)
1689                    && ! IS_ABSOLUTE_PATH (abfd->filename))
1690             normal = adjust_relative_path (filename, abfd->filename);
1691           else
1692             normal = filename;
1693         }
1694       else
1695         {
1696           normal = normalize (current, filename);
1697           if (normal == NULL)
1698             return FALSE;
1699         }
1700
1701       thislen = strlen (normal);
1702       if (thislen > maxname || bfd_is_thin_archive (abfd))
1703         {
1704           /* Works for now; may need to be re-engineered if we
1705              encounter an oddball archive format and want to
1706              generalise this hack.  */
1707           struct ar_hdr *hdr = arch_hdr (current);
1708           if (normal == last_filename)
1709             stroff = last_stroff;
1710           else
1711             {
1712               strcpy (strptr, normal);
1713               if (! trailing_slash)
1714                 strptr[thislen] = ARFMAG[1];
1715               else
1716                 {
1717                   strptr[thislen] = '/';
1718                   strptr[thislen + 1] = ARFMAG[1];
1719                 }
1720               stroff = strptr - *tabloc;
1721               last_stroff = stroff;
1722             }
1723           hdr->ar_name[0] = ar_padchar (current);
1724           if (bfd_is_thin_archive (abfd) && current->origin > 0)
1725             {
1726               int len = snprintf (hdr->ar_name + 1, maxname - 1, "%-ld:",
1727                                   stroff);
1728               _bfd_ar_spacepad (hdr->ar_name + 1 + len, maxname - 1 - len,
1729                                 "%-ld",
1730                                 current->origin - sizeof (struct ar_hdr));
1731             }
1732           else
1733             _bfd_ar_spacepad (hdr->ar_name + 1, maxname - 1, "%-ld", stroff);
1734           if (normal != last_filename)
1735             {
1736               strptr += thislen + 1;
1737               if (trailing_slash)
1738                 ++strptr;
1739               last_filename = filename;
1740             }
1741         }
1742     }
1743
1744   return TRUE;
1745 }
1746
1747 /* Do not construct an extended name table but transforms name field into
1748    its extended form.  */
1749
1750 bfd_boolean
1751 _bfd_archive_bsd44_construct_extended_name_table (bfd *abfd,
1752                                                   char **tabloc,
1753                                                   bfd_size_type *tablen,
1754                                                   const char **name)
1755 {
1756   unsigned int maxname = ar_maxnamelen (abfd);
1757   bfd *current;
1758
1759   *tablen = 0;
1760   *tabloc = NULL;
1761   *name = NULL;
1762
1763   for (current = abfd->archive_head;
1764        current != NULL;
1765        current = current->archive_next)
1766     {
1767       const char *normal = normalize (current, current->filename);
1768       int has_space = 0;
1769       unsigned int len;
1770
1771       if (normal == NULL)
1772         return FALSE;
1773
1774       for (len = 0; normal[len]; len++)
1775         if (normal[len] == ' ')
1776           has_space = 1;
1777
1778       if (len > maxname || has_space)
1779         {
1780           struct ar_hdr *hdr = arch_hdr (current);
1781
1782           len = (len + 3) & ~3;
1783           arch_eltdata (current)->extra_size = len;
1784           _bfd_ar_spacepad (hdr->ar_name, maxname, "#1/%lu", len);
1785         }
1786     }
1787
1788   return TRUE;
1789 }
1790 \f
1791 /* Write an archive header.  */
1792
1793 bfd_boolean
1794 _bfd_generic_write_ar_hdr (bfd *archive, bfd *abfd)
1795 {
1796   struct ar_hdr *hdr = arch_hdr (abfd);
1797
1798   if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
1799     return FALSE;
1800   return TRUE;
1801 }
1802
1803 /* Write an archive header using BSD4.4 convention.  */
1804
1805 bfd_boolean
1806 _bfd_bsd44_write_ar_hdr (bfd *archive, bfd *abfd)
1807 {
1808   struct ar_hdr *hdr = arch_hdr (abfd);
1809
1810   if (is_bsd44_extended_name (hdr->ar_name))
1811     {
1812       /* This is a BSD 4.4 extended name.  */
1813       const char *fullname = normalize (abfd, abfd->filename);
1814       unsigned int len = strlen (fullname);
1815       unsigned int padded_len = (len + 3) & ~3;
1816
1817       BFD_ASSERT (padded_len == arch_eltdata (abfd)->extra_size);
1818
1819       if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size),
1820                             arch_eltdata (abfd)->parsed_size + padded_len))
1821         return FALSE;
1822
1823       if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
1824         return FALSE;
1825
1826       if (bfd_bwrite (fullname, len, archive) != len)
1827         return FALSE;
1828
1829       if (len & 3)
1830         {
1831           static const char pad[3] = { 0, 0, 0 };
1832
1833           len = 4 - (len & 3);
1834           if (bfd_bwrite (pad, len, archive) != len)
1835             return FALSE;
1836         }
1837     }
1838   else
1839     {
1840       if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
1841         return FALSE;
1842     }
1843   return TRUE;
1844 }
1845 \f
1846 /* A couple of functions for creating ar_hdrs.  */
1847
1848 #ifdef HPUX_LARGE_AR_IDS
1849 /* Function to encode large UID/GID values according to HP.  */
1850
1851 static void
1852 hpux_uid_gid_encode (char str[6], long int id)
1853 {
1854   int cnt;
1855
1856   str[5] = '@' + (id & 3);
1857   id >>= 2;
1858
1859   for (cnt = 4; cnt >= 0; --cnt, id >>= 6)
1860     str[cnt] = ' ' + (id & 0x3f);
1861 }
1862 #endif  /* HPUX_LARGE_AR_IDS */
1863
1864 #ifndef HAVE_GETUID
1865 #define getuid() 0
1866 #endif
1867
1868 #ifndef HAVE_GETGID
1869 #define getgid() 0
1870 #endif
1871
1872 /* Takes a filename, returns an arelt_data for it, or NULL if it can't
1873    make one.  The filename must refer to a filename in the filesystem.
1874    The filename field of the ar_hdr will NOT be initialized.  If member
1875    is set, and it's an in-memory bfd, we fake it.  */
1876
1877 static struct areltdata *
1878 bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
1879 {
1880   struct stat status;
1881   struct areltdata *ared;
1882   struct ar_hdr *hdr;
1883   bfd_size_type amt;
1884
1885   if (member && (member->flags & BFD_IN_MEMORY) != 0)
1886     {
1887       /* Assume we just "made" the member, and fake it.  */
1888       struct bfd_in_memory *bim = (struct bfd_in_memory *) member->iostream;
1889       time (&status.st_mtime);
1890       status.st_uid = getuid ();
1891       status.st_gid = getgid ();
1892       status.st_mode = 0644;
1893       status.st_size = bim->size;
1894     }
1895   else if (stat (filename, &status) != 0)
1896     {
1897       bfd_set_error (bfd_error_system_call);
1898       return NULL;
1899     }
1900
1901   /* If the caller requested that the BFD generate deterministic output,
1902      fake values for modification time, UID, GID, and file mode.  */
1903   if ((abfd->flags & BFD_DETERMINISTIC_OUTPUT) != 0)
1904     {
1905       status.st_mtime = 0;
1906       status.st_uid = 0;
1907       status.st_gid = 0;
1908       status.st_mode = 0644;
1909     }
1910
1911   amt = sizeof (struct ar_hdr) + sizeof (struct areltdata);
1912   ared = (struct areltdata *) bfd_zmalloc (amt);
1913   if (ared == NULL)
1914     return NULL;
1915   hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));
1916
1917   /* ar headers are space padded, not null padded!  */
1918   memset (hdr, ' ', sizeof (struct ar_hdr));
1919
1920   _bfd_ar_spacepad (hdr->ar_date, sizeof (hdr->ar_date), "%-12ld",
1921                     status.st_mtime);
1922 #ifdef HPUX_LARGE_AR_IDS
1923   /* HP has a very "special" way to handle UID/GID's with numeric values
1924      > 99999.  */
1925   if (status.st_uid > 99999)
1926     hpux_uid_gid_encode (hdr->ar_uid, (long) status.st_uid);
1927   else
1928 #endif
1929     _bfd_ar_spacepad (hdr->ar_uid, sizeof (hdr->ar_uid), "%ld",
1930                       status.st_uid);
1931 #ifdef HPUX_LARGE_AR_IDS
1932   /* HP has a very "special" way to handle UID/GID's with numeric values
1933      > 99999.  */
1934   if (status.st_gid > 99999)
1935     hpux_uid_gid_encode (hdr->ar_gid, (long) status.st_gid);
1936   else
1937 #endif
1938     _bfd_ar_spacepad (hdr->ar_gid, sizeof (hdr->ar_gid), "%ld",
1939                       status.st_gid);
1940   _bfd_ar_spacepad (hdr->ar_mode, sizeof (hdr->ar_mode), "%-8lo",
1941                     status.st_mode);
1942   if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size), status.st_size))
1943     {
1944       free (ared);
1945       return NULL;
1946     }
1947   memcpy (hdr->ar_fmag, ARFMAG, 2);
1948   ared->parsed_size = status.st_size;
1949   ared->arch_header = (char *) hdr;
1950
1951   return ared;
1952 }
1953
1954 /* Analogous to stat call.  */
1955
1956 int
1957 bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
1958 {
1959   struct ar_hdr *hdr;
1960   char *aloser;
1961
1962   if (abfd->arelt_data == NULL)
1963     {
1964       bfd_set_error (bfd_error_invalid_operation);
1965       return -1;
1966     }
1967
1968   hdr = arch_hdr (abfd);
1969
1970 #define foo(arelt, stelt, size)                         \
1971   buf->stelt = strtol (hdr->arelt, &aloser, size);      \
1972   if (aloser == hdr->arelt)                             \
1973     return -1;
1974
1975   /* Some platforms support special notations for large IDs.  */
1976 #ifdef HPUX_LARGE_AR_IDS
1977 # define foo2(arelt, stelt, size)                                       \
1978   if (hdr->arelt[5] == ' ')                                             \
1979     {                                                                   \
1980       foo (arelt, stelt, size);                                         \
1981     }                                                                   \
1982   else                                                                  \
1983     {                                                                   \
1984       int cnt;                                                          \
1985       for (buf->stelt = cnt = 0; cnt < 5; ++cnt)                        \
1986         {                                                               \
1987           if (hdr->arelt[cnt] < ' ' || hdr->arelt[cnt] > ' ' + 0x3f)    \
1988             return -1;                                                  \
1989           buf->stelt <<= 6;                                             \
1990           buf->stelt += hdr->arelt[cnt] - ' ';                          \
1991         }                                                               \
1992       if (hdr->arelt[5] < '@' || hdr->arelt[5] > '@' + 3)               \
1993         return -1;                                                      \
1994       buf->stelt <<= 2;                                                 \
1995       buf->stelt += hdr->arelt[5] - '@';                                \
1996     }
1997 #else
1998 # define foo2(arelt, stelt, size) foo (arelt, stelt, size)
1999 #endif
2000
2001   foo (ar_date, st_mtime, 10);
2002   foo2 (ar_uid, st_uid, 10);
2003   foo2 (ar_gid, st_gid, 10);
2004   foo (ar_mode, st_mode, 8);
2005
2006   buf->st_size = arch_eltdata (abfd)->parsed_size;
2007
2008   return 0;
2009 }
2010
2011 void
2012 bfd_dont_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
2013 {
2014   /* FIXME: This interacts unpleasantly with ar's quick-append option.
2015      Fortunately ic960 users will never use that option.  Fixing this
2016      is very hard; fortunately I know how to do it and will do so once
2017      intel's release is out the door.  */
2018
2019   struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
2020   size_t length;
2021   const char *filename;
2022   size_t maxlen = ar_maxnamelen (abfd);
2023
2024   if ((bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
2025     {
2026       bfd_bsd_truncate_arname (abfd, pathname, arhdr);
2027       return;
2028     }
2029
2030   filename = normalize (abfd, pathname);
2031   if (filename == NULL)
2032     {
2033       /* FIXME */
2034       abort ();
2035     }
2036
2037   length = strlen (filename);
2038
2039   if (length <= maxlen)
2040     memcpy (hdr->ar_name, filename, length);
2041
2042   /* Add the padding character if there is room for it.  */
2043   if (length < maxlen
2044       || (length == maxlen && length < sizeof hdr->ar_name))
2045     (hdr->ar_name)[length] = ar_padchar (abfd);
2046 }
2047
2048 void
2049 bfd_bsd_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
2050 {
2051   struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
2052   size_t length;
2053   const char *filename = lbasename (pathname);
2054   size_t maxlen = ar_maxnamelen (abfd);
2055
2056   length = strlen (filename);
2057
2058   if (length <= maxlen)
2059     memcpy (hdr->ar_name, filename, length);
2060   else
2061     {
2062       /* pathname: meet procrustes */
2063       memcpy (hdr->ar_name, filename, maxlen);
2064       length = maxlen;
2065     }
2066
2067   if (length < maxlen)
2068     (hdr->ar_name)[length] = ar_padchar (abfd);
2069 }
2070
2071 /* Store name into ar header.  Truncates the name to fit.
2072    1> strip pathname to be just the basename.
2073    2> if it's short enuf to fit, stuff it in.
2074    3> If it doesn't end with .o, truncate it to fit
2075    4> truncate it before the .o, append .o, stuff THAT in.  */
2076
2077 /* This is what gnu ar does.  It's better but incompatible with the
2078    bsd ar.  */
2079
2080 void
2081 bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
2082 {
2083   struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
2084   size_t length;
2085   const char *filename = lbasename (pathname);
2086   size_t maxlen = ar_maxnamelen (abfd);
2087
2088   length = strlen (filename);
2089
2090   if (length <= maxlen)
2091     memcpy (hdr->ar_name, filename, length);
2092   else
2093     {
2094       /* pathname: meet procrustes.  */
2095       memcpy (hdr->ar_name, filename, maxlen);
2096       if ((filename[length - 2] == '.') && (filename[length - 1] == 'o'))
2097         {
2098           hdr->ar_name[maxlen - 2] = '.';
2099           hdr->ar_name[maxlen - 1] = 'o';
2100         }
2101       length = maxlen;
2102     }
2103
2104   if (length < 16)
2105     (hdr->ar_name)[length] = ar_padchar (abfd);
2106 }
2107 \f
2108 /* The BFD is open for write and has its format set to bfd_archive.  */
2109
2110 bfd_boolean
2111 _bfd_write_archive_contents (bfd *arch)
2112 {
2113   bfd *current;
2114   char *etable = NULL;
2115   bfd_size_type elength = 0;
2116   const char *ename = NULL;
2117   bfd_boolean makemap = bfd_has_map (arch);
2118   /* If no .o's, don't bother to make a map.  */
2119   bfd_boolean hasobjects = FALSE;
2120   bfd_size_type wrote;
2121   int tries;
2122   char *armag;
2123
2124   /* Verify the viability of all entries; if any of them live in the
2125      filesystem (as opposed to living in an archive open for input)
2126      then construct a fresh ar_hdr for them.  */
2127   for (current = arch->archive_head;
2128        current != NULL;
2129        current = current->archive_next)
2130     {
2131       /* This check is checking the bfds for the objects we're reading
2132          from (which are usually either an object file or archive on
2133          disk), not the archive entries we're writing to.  We don't
2134          actually create bfds for the archive members, we just copy
2135          them byte-wise when we write out the archive.  */
2136       if (bfd_write_p (current))
2137         {
2138           bfd_set_error (bfd_error_invalid_operation);
2139           goto input_err;
2140         }
2141       if (!current->arelt_data)
2142         {
2143           current->arelt_data =
2144             bfd_ar_hdr_from_filesystem (arch, current->filename, current);
2145           if (!current->arelt_data)
2146             goto input_err;
2147
2148           /* Put in the file name.  */
2149           BFD_SEND (arch, _bfd_truncate_arname,
2150                     (arch, current->filename, (char *) arch_hdr (current)));
2151         }
2152
2153       if (makemap && ! hasobjects)
2154         {                       /* Don't bother if we won't make a map!  */
2155           if ((bfd_check_format (current, bfd_object)))
2156             hasobjects = TRUE;
2157         }
2158     }
2159
2160   if (!BFD_SEND (arch, _bfd_construct_extended_name_table,
2161                  (arch, &etable, &elength, &ename)))
2162     return FALSE;
2163
2164   if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0)
2165     return FALSE;
2166   armag = ARMAG;
2167   if (bfd_is_thin_archive (arch))
2168     armag = ARMAGT;
2169   wrote = bfd_bwrite (armag, SARMAG, arch);
2170   if (wrote != SARMAG)
2171     return FALSE;
2172
2173   if (makemap && hasobjects)
2174     {
2175       if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength))
2176         return FALSE;
2177     }
2178
2179   if (elength != 0)
2180     {
2181       struct ar_hdr hdr;
2182
2183       memset (&hdr, ' ', sizeof (struct ar_hdr));
2184       memcpy (hdr.ar_name, ename, strlen (ename));
2185       /* Round size up to even number in archive header.  */
2186       if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size),
2187                             (elength + 1) & ~(bfd_size_type) 1))
2188         return FALSE;
2189       memcpy (hdr.ar_fmag, ARFMAG, 2);
2190       if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2191            != sizeof (struct ar_hdr))
2192           || bfd_bwrite (etable, elength, arch) != elength)
2193         return FALSE;
2194       if ((elength % 2) == 1)
2195         {
2196           if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)
2197             return FALSE;
2198         }
2199     }
2200
2201   for (current = arch->archive_head;
2202        current != NULL;
2203        current = current->archive_next)
2204     {
2205       char buffer[DEFAULT_BUFFERSIZE];
2206       bfd_size_type remaining = arelt_size (current);
2207
2208       /* Write ar header.  */
2209       if (!_bfd_write_ar_hdr (arch, current))
2210         return FALSE;
2211       if (bfd_is_thin_archive (arch))
2212         continue;
2213       if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
2214         goto input_err;
2215
2216       while (remaining)
2217         {
2218           unsigned int amt = DEFAULT_BUFFERSIZE;
2219
2220           if (amt > remaining)
2221             amt = remaining;
2222           errno = 0;
2223           if (bfd_bread (buffer, amt, current) != amt)
2224             {
2225               if (bfd_get_error () != bfd_error_system_call)
2226                 bfd_set_error (bfd_error_file_truncated);
2227               goto input_err;
2228             }
2229           if (bfd_bwrite (buffer, amt, arch) != amt)
2230             return FALSE;
2231           remaining -= amt;
2232         }
2233
2234       if ((arelt_size (current) % 2) == 1)
2235         {
2236           if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)
2237             return FALSE;
2238         }
2239     }
2240
2241   if (makemap && hasobjects)
2242     {
2243       /* Verify the timestamp in the archive file.  If it would not be
2244          accepted by the linker, rewrite it until it would be.  If
2245          anything odd happens, break out and just return.  (The
2246          Berkeley linker checks the timestamp and refuses to read the
2247          table-of-contents if it is >60 seconds less than the file's
2248          modified-time.  That painful hack requires this painful hack.  */
2249       tries = 1;
2250       do
2251         {
2252           if (bfd_update_armap_timestamp (arch))
2253             break;
2254           (*_bfd_error_handler)
2255             (_("Warning: writing archive was slow: rewriting timestamp\n"));
2256         }
2257       while (++tries < 6);
2258     }
2259
2260   return TRUE;
2261
2262  input_err:
2263   bfd_set_error (bfd_error_on_input, current, bfd_get_error ());
2264   return FALSE;
2265 }
2266 \f
2267 /* Note that the namidx for the first symbol is 0.  */
2268
2269 bfd_boolean
2270 _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
2271 {
2272   char *first_name = NULL;
2273   bfd *current;
2274   file_ptr elt_no = 0;
2275   struct orl *map = NULL;
2276   unsigned int orl_max = 1024;          /* Fine initial default.  */
2277   unsigned int orl_count = 0;
2278   int stridx = 0;
2279   asymbol **syms = NULL;
2280   long syms_max = 0;
2281   bfd_boolean ret;
2282   bfd_size_type amt;
2283
2284   /* Dunno if this is the best place for this info...  */
2285   if (elength != 0)
2286     elength += sizeof (struct ar_hdr);
2287   elength += elength % 2;
2288
2289   amt = orl_max * sizeof (struct orl);
2290   map = (struct orl *) bfd_malloc (amt);
2291   if (map == NULL)
2292     goto error_return;
2293
2294   /* We put the symbol names on the arch objalloc, and then discard
2295      them when done.  */
2296   first_name = (char *) bfd_alloc (arch, 1);
2297   if (first_name == NULL)
2298     goto error_return;
2299
2300   /* Drop all the files called __.SYMDEF, we're going to make our own.  */
2301   while (arch->archive_head
2302          && strcmp (arch->archive_head->filename, "__.SYMDEF") == 0)
2303     arch->archive_head = arch->archive_head->archive_next;
2304
2305   /* Map over each element.  */
2306   for (current = arch->archive_head;
2307        current != NULL;
2308        current = current->archive_next, elt_no++)
2309     {
2310       if (bfd_check_format (current, bfd_object)
2311           && (bfd_get_file_flags (current) & HAS_SYMS) != 0)
2312         {
2313           long storage;
2314           long symcount;
2315           long src_count;
2316
2317           storage = bfd_get_symtab_upper_bound (current);
2318           if (storage < 0)
2319             goto error_return;
2320
2321           if (storage != 0)
2322             {
2323               if (storage > syms_max)
2324                 {
2325                   if (syms_max > 0)
2326                     free (syms);
2327                   syms_max = storage;
2328                   syms = (asymbol **) bfd_malloc (syms_max);
2329                   if (syms == NULL)
2330                     goto error_return;
2331                 }
2332               symcount = bfd_canonicalize_symtab (current, syms);
2333               if (symcount < 0)
2334                 goto error_return;
2335
2336               /* Now map over all the symbols, picking out the ones we
2337                  want.  */
2338               for (src_count = 0; src_count < symcount; src_count++)
2339                 {
2340                   flagword flags = (syms[src_count])->flags;
2341                   asection *sec = syms[src_count]->section;
2342
2343                   if (((flags & (BSF_GLOBAL
2344                                  | BSF_WEAK
2345                                  | BSF_INDIRECT
2346                                  | BSF_GNU_UNIQUE)) != 0
2347                        || bfd_is_com_section (sec))
2348                       && ! bfd_is_und_section (sec))
2349                     {
2350                       bfd_size_type namelen;
2351                       struct orl *new_map;
2352
2353                       /* This symbol will go into the archive header.  */
2354                       if (orl_count == orl_max)
2355                         {
2356                           orl_max *= 2;
2357                           amt = orl_max * sizeof (struct orl);
2358                           new_map = (struct orl *) bfd_realloc (map, amt);
2359                           if (new_map == NULL)
2360                             goto error_return;
2361
2362                           map = new_map;
2363                         }
2364
2365                       if (strcmp (syms[src_count]->name, "__gnu_lto_slim") == 0)
2366                         (*_bfd_error_handler)
2367                           (_("%s: plugin needed to handle lto object"),
2368                            bfd_get_filename (current));
2369                       namelen = strlen (syms[src_count]->name);
2370                       amt = sizeof (char *);
2371                       map[orl_count].name = (char **) bfd_alloc (arch, amt);
2372                       if (map[orl_count].name == NULL)
2373                         goto error_return;
2374                       *(map[orl_count].name) = (char *) bfd_alloc (arch,
2375                                                                    namelen + 1);
2376                       if (*(map[orl_count].name) == NULL)
2377                         goto error_return;
2378                       strcpy (*(map[orl_count].name), syms[src_count]->name);
2379                       map[orl_count].u.abfd = current;
2380                       map[orl_count].namidx = stridx;
2381
2382                       stridx += namelen + 1;
2383                       ++orl_count;
2384                     }
2385                 }
2386             }
2387
2388           /* Now ask the BFD to free up any cached information, so we
2389              don't fill all of memory with symbol tables.  */
2390           if (! bfd_free_cached_info (current))
2391             goto error_return;
2392         }
2393     }
2394
2395   /* OK, now we have collected all the data, let's write them out.  */
2396   ret = BFD_SEND (arch, write_armap,
2397                   (arch, elength, map, orl_count, stridx));
2398
2399   if (syms_max > 0)
2400     free (syms);
2401   if (map != NULL)
2402     free (map);
2403   if (first_name != NULL)
2404     bfd_release (arch, first_name);
2405
2406   return ret;
2407
2408  error_return:
2409   if (syms_max > 0)
2410     free (syms);
2411   if (map != NULL)
2412     free (map);
2413   if (first_name != NULL)
2414     bfd_release (arch, first_name);
2415
2416   return FALSE;
2417 }
2418
2419 bfd_boolean
2420 bsd_write_armap (bfd *arch,
2421                  unsigned int elength,
2422                  struct orl *map,
2423                  unsigned int orl_count,
2424                  int stridx)
2425 {
2426   int padit = stridx & 1;
2427   unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE;
2428   unsigned int stringsize = stridx + padit;
2429   /* Include 8 bytes to store ranlibsize and stringsize in output.  */
2430   unsigned int mapsize = ranlibsize + stringsize + 8;
2431   file_ptr firstreal;
2432   bfd *current = arch->archive_head;
2433   bfd *last_elt = current;      /* Last element arch seen.  */
2434   bfd_byte temp[4];
2435   unsigned int count;
2436   struct ar_hdr hdr;
2437   long uid, gid;
2438
2439   firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
2440
2441   /* If deterministic, we use 0 as the timestamp in the map.
2442      Some linkers may require that the archive filesystem modification
2443      time is less than (or near to) the archive map timestamp.  Those
2444      linkers should not be used with deterministic mode.  (GNU ld and
2445      Gold do not have this restriction.)  */
2446   bfd_ardata (arch)->armap_timestamp = 0;
2447   uid = 0;
2448   gid = 0;
2449   if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0)
2450     {
2451       struct stat statbuf;
2452
2453       if (stat (arch->filename, &statbuf) == 0)
2454         bfd_ardata (arch)->armap_timestamp = (statbuf.st_mtime
2455                                               + ARMAP_TIME_OFFSET);
2456       uid = getuid();
2457       gid = getgid();
2458     }
2459
2460   memset (&hdr, ' ', sizeof (struct ar_hdr));
2461   memcpy (hdr.ar_name, RANLIBMAG, strlen (RANLIBMAG));
2462   bfd_ardata (arch)->armap_datepos = (SARMAG
2463                                       + offsetof (struct ar_hdr, ar_date[0]));
2464   _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2465                     bfd_ardata (arch)->armap_timestamp);
2466   _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", uid);
2467   _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", gid);
2468   if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))
2469     return FALSE;
2470   memcpy (hdr.ar_fmag, ARFMAG, 2);
2471   if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2472       != sizeof (struct ar_hdr))
2473     return FALSE;
2474   H_PUT_32 (arch, ranlibsize, temp);
2475   if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
2476     return FALSE;
2477
2478   for (count = 0; count < orl_count; count++)
2479     {
2480       unsigned int offset;
2481       bfd_byte buf[BSD_SYMDEF_SIZE];
2482
2483       if (map[count].u.abfd != last_elt)
2484         {
2485           do
2486             {
2487               struct areltdata *ared = arch_eltdata (current);
2488
2489               firstreal += (ared->parsed_size + ared->extra_size
2490                             + sizeof (struct ar_hdr));
2491               firstreal += firstreal % 2;
2492               current = current->archive_next;
2493             }
2494           while (current != map[count].u.abfd);
2495         }
2496
2497       /* The archive file format only has 4 bytes to store the offset
2498          of the member.  Check to make sure that firstreal has not grown
2499          too big.  */
2500       offset = (unsigned int) firstreal;
2501       if (firstreal != (file_ptr) offset)
2502         {
2503           bfd_set_error (bfd_error_file_truncated);
2504           return FALSE;
2505         }
2506
2507       last_elt = current;
2508       H_PUT_32 (arch, map[count].namidx, buf);
2509       H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE);
2510       if (bfd_bwrite (buf, BSD_SYMDEF_SIZE, arch)
2511           != BSD_SYMDEF_SIZE)
2512         return FALSE;
2513     }
2514
2515   /* Now write the strings themselves.  */
2516   H_PUT_32 (arch, stringsize, temp);
2517   if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
2518     return FALSE;
2519   for (count = 0; count < orl_count; count++)
2520     {
2521       size_t len = strlen (*map[count].name) + 1;
2522
2523       if (bfd_bwrite (*map[count].name, len, arch) != len)
2524         return FALSE;
2525     }
2526
2527   /* The spec sez this should be a newline.  But in order to be
2528      bug-compatible for sun's ar we use a null.  */
2529   if (padit)
2530     {
2531       if (bfd_bwrite ("", 1, arch) != 1)
2532         return FALSE;
2533     }
2534
2535   return TRUE;
2536 }
2537
2538 /* At the end of archive file handling, update the timestamp in the
2539    file, so the linker will accept it.
2540
2541    Return TRUE if the timestamp was OK, or an unusual problem happened.
2542    Return FALSE if we updated the timestamp.  */
2543
2544 bfd_boolean
2545 _bfd_archive_bsd_update_armap_timestamp (bfd *arch)
2546 {
2547   struct stat archstat;
2548   struct ar_hdr hdr;
2549
2550   /* If creating deterministic archives, just leave the timestamp as-is.  */
2551   if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) != 0)
2552     return TRUE;
2553
2554   /* Flush writes, get last-write timestamp from file, and compare it
2555      to the timestamp IN the file.  */
2556   bfd_flush (arch);
2557   if (bfd_stat (arch, &archstat) == -1)
2558     {
2559       bfd_perror (_("Reading archive file mod timestamp"));
2560
2561       /* Can't read mod time for some reason.  */
2562       return TRUE;
2563     }
2564   if (((long) archstat.st_mtime) <= bfd_ardata (arch)->armap_timestamp)
2565     /* OK by the linker's rules.  */
2566     return TRUE;
2567
2568   /* Update the timestamp.  */
2569   bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET;
2570
2571   /* Prepare an ASCII version suitable for writing.  */
2572   memset (hdr.ar_date, ' ', sizeof (hdr.ar_date));
2573   _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2574                     bfd_ardata (arch)->armap_timestamp);
2575
2576   /* Write it into the file.  */
2577   bfd_ardata (arch)->armap_datepos = (SARMAG
2578                                       + offsetof (struct ar_hdr, ar_date[0]));
2579   if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0
2580       || (bfd_bwrite (hdr.ar_date, sizeof (hdr.ar_date), arch)
2581           != sizeof (hdr.ar_date)))
2582     {
2583       bfd_perror (_("Writing updated armap timestamp"));
2584
2585       /* Some error while writing.  */
2586       return TRUE;
2587     }
2588
2589   /* We updated the timestamp successfully.  */
2590   return FALSE;
2591 }
2592 \f
2593 /* A coff armap looks like :
2594    lARMAG
2595    struct ar_hdr with name = '/'
2596    number of symbols
2597    offset of file for symbol 0
2598    offset of file for symbol 1
2599
2600    offset of file for symbol n-1
2601    symbol name 0
2602    symbol name 1
2603
2604    symbol name n-1  */
2605
2606 bfd_boolean
2607 coff_write_armap (bfd *arch,
2608                   unsigned int elength,
2609                   struct orl *map,
2610                   unsigned int symbol_count,
2611                   int stridx)
2612 {
2613   /* The size of the ranlib is the number of exported symbols in the
2614      archive * the number of bytes in an int, + an int for the count.  */
2615   unsigned int ranlibsize = (symbol_count * 4) + 4;
2616   unsigned int stringsize = stridx;
2617   unsigned int mapsize = stringsize + ranlibsize;
2618   file_ptr archive_member_file_ptr;
2619   bfd *current = arch->archive_head;
2620   unsigned int count;
2621   struct ar_hdr hdr;
2622   int padit = mapsize & 1;
2623
2624   if (padit)
2625     mapsize++;
2626
2627   /* Work out where the first object file will go in the archive.  */
2628   archive_member_file_ptr = (mapsize
2629                              + elength
2630                              + sizeof (struct ar_hdr)
2631                              + SARMAG);
2632
2633   memset (&hdr, ' ', sizeof (struct ar_hdr));
2634   hdr.ar_name[0] = '/';
2635   if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))
2636     return FALSE;
2637   _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2638                     ((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0
2639                      ? time (NULL) : 0));
2640   /* This, at least, is what Intel coff sets the values to.  */
2641   _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", 0);
2642   _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", 0);
2643   _bfd_ar_spacepad (hdr.ar_mode, sizeof (hdr.ar_mode), "%-7lo", 0);
2644   memcpy (hdr.ar_fmag, ARFMAG, 2);
2645
2646   /* Write the ar header for this item and the number of symbols.  */
2647   if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2648       != sizeof (struct ar_hdr))
2649     return FALSE;
2650
2651   if (!bfd_write_bigendian_4byte_int (arch, symbol_count))
2652     return FALSE;
2653
2654   /* Two passes, first write the file offsets for each symbol -
2655      remembering that each offset is on a two byte boundary.  */
2656
2657   /* Write out the file offset for the file associated with each
2658      symbol, and remember to keep the offsets padded out.  */
2659
2660   current = arch->archive_head;
2661   count = 0;
2662   while (current != NULL && count < symbol_count)
2663     {
2664       /* For each symbol which is used defined in this object, write
2665          out the object file's address in the archive.  */
2666
2667       while (count < symbol_count && map[count].u.abfd == current)
2668         {
2669           unsigned int offset = (unsigned int) archive_member_file_ptr;
2670
2671           /* Catch an attempt to grow an archive past its 4Gb limit.  */
2672           if (archive_member_file_ptr != (file_ptr) offset)
2673             {
2674               bfd_set_error (bfd_error_file_truncated);
2675               return FALSE;
2676             }
2677           if (!bfd_write_bigendian_4byte_int (arch, offset))
2678             return FALSE;
2679           count++;
2680         }
2681       archive_member_file_ptr += sizeof (struct ar_hdr);
2682       if (! bfd_is_thin_archive (arch))
2683         {
2684           /* Add size of this archive entry.  */
2685           archive_member_file_ptr += arelt_size (current);
2686           /* Remember about the even alignment.  */
2687           archive_member_file_ptr += archive_member_file_ptr % 2;
2688         }
2689       current = current->archive_next;
2690     }
2691
2692   /* Now write the strings themselves.  */
2693   for (count = 0; count < symbol_count; count++)
2694     {
2695       size_t len = strlen (*map[count].name) + 1;
2696
2697       if (bfd_bwrite (*map[count].name, len, arch) != len)
2698         return FALSE;
2699     }
2700
2701   /* The spec sez this should be a newline.  But in order to be
2702      bug-compatible for arc960 we use a null.  */
2703   if (padit)
2704     {
2705       if (bfd_bwrite ("", 1, arch) != 1)
2706         return FALSE;
2707     }
2708
2709   return TRUE;
2710 }
2711
2712 static int
2713 archive_close_worker (void **slot, void *inf ATTRIBUTE_UNUSED)
2714 {
2715   struct ar_cache *ent = (struct ar_cache *) *slot;
2716
2717   bfd_close_all_done (ent->arbfd);
2718   return 1;
2719 }
2720
2721 bfd_boolean
2722 _bfd_archive_close_and_cleanup (bfd *abfd)
2723 {
2724   if (bfd_read_p (abfd) && abfd->format == bfd_archive)
2725     {
2726       bfd *nbfd;
2727       bfd *next;
2728       htab_t htab;
2729
2730       /* Close nested archives (if this bfd is a thin archive).  */
2731       for (nbfd = abfd->nested_archives; nbfd; nbfd = next)
2732         {
2733           next = nbfd->archive_next;
2734           bfd_close (nbfd);
2735         }
2736
2737       htab = bfd_ardata (abfd)->cache;
2738       if (htab)
2739         {
2740           htab_traverse_noresize (htab, archive_close_worker, NULL);
2741           htab_delete (htab);
2742           bfd_ardata (abfd)->cache = NULL;
2743         }
2744     }
2745   if (arch_eltdata (abfd) != NULL)
2746     {
2747       struct areltdata *ared = arch_eltdata (abfd);
2748       htab_t htab = (htab_t) ared->parent_cache;
2749
2750       if (htab)
2751         {
2752           struct ar_cache ent;
2753           void **slot;
2754
2755           ent.ptr = ared->key;
2756           slot = htab_find_slot (htab, &ent, NO_INSERT);
2757           if (slot != NULL)
2758             {
2759               BFD_ASSERT (((struct ar_cache *) *slot)->arbfd == abfd);
2760               htab_clear_slot (htab, slot);
2761             }
2762         }
2763     }
2764   if (abfd->is_linker_output)
2765     (*abfd->link.hash->hash_table_free) (abfd);
2766
2767   return TRUE;
2768 }