bfd/archive.c

   1 /* BFD back-end for archive files (libraries).
   2    Copyright (C) 1990-2015 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   /* PR 17512: file: 883ff754.  */
 906   /* PR 17512: file: 0458885f.  */
 907   if (parsed_size < 4)
 908     return FALSE;
 909
 910   raw_armap = (bfd_byte *) bfd_zalloc (abfd, parsed_size);
 911   if (raw_armap == NULL)
 912     return FALSE;
 913
 914   if (bfd_bread (raw_armap, parsed_size, abfd) != parsed_size)
 915     {
 916       if (bfd_get_error () != bfd_error_system_call)
 917         bfd_set_error (bfd_error_malformed_archive);
 918     byebye:
 919       bfd_release (abfd, raw_armap);
 920       return FALSE;
 921     }
 922
 923   ardata->symdef_count = H_GET_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE;
 924   if (ardata->symdef_count * BSD_SYMDEF_SIZE >
 925       parsed_size - BSD_SYMDEF_COUNT_SIZE)
 926     {
 927       /* Probably we're using the wrong byte ordering.  */
 928       bfd_set_error (bfd_error_wrong_format);
 929       goto byebye;
 930     }
 931
 932   ardata->cache = 0;
 933   rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE;
 934   stringbase = ((char *) rbase
 935                 + ardata->symdef_count * BSD_SYMDEF_SIZE
 936                 + BSD_STRING_COUNT_SIZE);
 937   amt = ardata->symdef_count * sizeof (carsym);
 938   ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt);
 939   if (!ardata->symdefs)
 940     return FALSE;
 941
 942   for (counter = 0, set = ardata->symdefs;
 943        counter < ardata->symdef_count;
 944        counter++, set++, rbase += BSD_SYMDEF_SIZE)
 945     {
 946       set->name = H_GET_32 (abfd, rbase) + stringbase;
 947       set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
 948     }
 949
 950   ardata->first_file_filepos = bfd_tell (abfd);
 951   /* Pad to an even boundary if you have to.  */
 952   ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
 953   /* FIXME, we should provide some way to free raw_ardata when
 954      we are done using the strings from it.  For now, it seems
 955      to be allocated on an objalloc anyway...  */
 956   bfd_has_map (abfd) = TRUE;
 957   return TRUE;
 958 }
 959
 960 /* Read a COFF archive symbol table.  Returns FALSE on error, TRUE
 961    otherwise.  */
 962
 963 static bfd_boolean
 964 do_slurp_coff_armap (bfd *abfd)
 965 {
 966   struct areltdata *mapdata;
 967   int *raw_armap, *rawptr;
 968   struct artdata *ardata = bfd_ardata (abfd);
 969   char *stringbase;
 970   bfd_size_type stringsize;
 971   bfd_size_type parsed_size;
 972   carsym *carsyms;
 973   bfd_size_type nsymz;          /* Number of symbols in armap.  */
 974   bfd_vma (*swap) (const void *);
 975   char int_buf[sizeof (long)];
 976   bfd_size_type carsym_size, ptrsize;
 977   unsigned int i;
 978
 979   mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
 980   if (mapdata == NULL)
 981     return FALSE;
 982   parsed_size = mapdata->parsed_size;
 983   free (mapdata);
 984
 985   if (bfd_bread (int_buf, 4, abfd) != 4)
 986     {
 987       if (bfd_get_error () != bfd_error_system_call)
 988         bfd_set_error (bfd_error_malformed_archive);
 989       return FALSE;
 990     }
 991   /* It seems that all numeric information in a coff archive is always
 992      in big endian format, nomatter the host or target.  */
 993   swap = bfd_getb32;
 994   nsymz = bfd_getb32 (int_buf);
 995   stringsize = parsed_size - (4 * nsymz) - 4;
 996
 997   /* ... except that some archive formats are broken, and it may be our
 998      fault - the i960 little endian coff sometimes has big and sometimes
 999      little, because our tools changed.  Here's a horrible hack to clean
1000      up the crap.  */
1001
1002   if (stringsize > 0xfffff
1003       && bfd_get_arch (abfd) == bfd_arch_i960
1004       && bfd_get_flavour (abfd) == bfd_target_coff_flavour)
1005     {
1006       /* This looks dangerous, let's do it the other way around.  */
1007       nsymz = bfd_getl32 (int_buf);
1008       stringsize = parsed_size - (4 * nsymz) - 4;
1009       swap = bfd_getl32;
1010     }
1011
1012   /* The coff armap must be read sequentially.  So we construct a
1013      bsd-style one in core all at once, for simplicity.  */
1014
1015   if (nsymz > ~ (bfd_size_type) 0 / sizeof (carsym))
1016     return FALSE;
1017
1018   carsym_size = (nsymz * sizeof (carsym));
1019   ptrsize = (4 * nsymz);
1020
1021   if (carsym_size + stringsize + 1 <= carsym_size)
1022     return FALSE;
1023
1024   ardata->symdefs = (struct carsym *) bfd_zalloc (abfd,
1025                                                   carsym_size + stringsize + 1);
1026   if (ardata->symdefs == NULL)
1027     return FALSE;
1028   carsyms = ardata->symdefs;
1029   stringbase = ((char *) ardata->symdefs) + carsym_size;
1030
1031   /* Allocate and read in the raw offsets.  */
1032   raw_armap = (int *) bfd_alloc (abfd, ptrsize);
1033   if (raw_armap == NULL)
1034     goto release_symdefs;
1035   if (bfd_bread (raw_armap, ptrsize, abfd) != ptrsize
1036       || (bfd_bread (stringbase, stringsize, abfd) != stringsize))
1037     {
1038       if (bfd_get_error () != bfd_error_system_call)
1039         bfd_set_error (bfd_error_malformed_archive);
1040       goto release_raw_armap;
1041     }
1042
1043   /* OK, build the carsyms.  */
1044   for (i = 0; i < nsymz && stringsize > 0; i++)
1045     {
1046       bfd_size_type len;
1047
1048       rawptr = raw_armap + i;
1049       carsyms->file_offset = swap ((bfd_byte *) rawptr);
1050       carsyms->name = stringbase;
1051       /* PR 17512: file: 4a1d50c1.  */
1052       len = strnlen (stringbase, stringsize);
1053       if (len < stringsize)
1054         len ++;
1055       stringbase += len;
1056       stringsize -= len;
1057       carsyms++;
1058     }
1059   *stringbase = 0;
1060
1061   ardata->symdef_count = nsymz;
1062   ardata->first_file_filepos = bfd_tell (abfd);
1063   /* Pad to an even boundary if you have to.  */
1064   ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1065
1066   bfd_has_map (abfd) = TRUE;
1067   bfd_release (abfd, raw_armap);
1068
1069   /* Check for a second archive header (as used by PE).  */
1070   {
1071     struct areltdata *tmp;
1072
1073     bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET);
1074     tmp = (struct areltdata *) _bfd_read_ar_hdr (abfd);
1075     if (tmp != NULL)
1076       {
1077         if (tmp->arch_header[0] == '/'
1078             && tmp->arch_header[1] == ' ')
1079           {
1080             ardata->first_file_filepos +=
1081               (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1;
1082           }
1083         free (tmp);
1084       }
1085   }
1086
1087   return TRUE;
1088
1089 release_raw_armap:
1090   bfd_release (abfd, raw_armap);
1091 release_symdefs:
1092   bfd_release (abfd, (ardata)->symdefs);
1093   return FALSE;
1094 }
1095
1096 /* This routine can handle either coff-style or bsd-style armaps
1097    (archive symbol table).  Returns FALSE on error, TRUE otherwise */
1098
1099 bfd_boolean
1100 bfd_slurp_armap (bfd *abfd)
1101 {
1102   char nextname[17];
1103   int i = bfd_bread (nextname, 16, abfd);
1104
1105   if (i == 0)
1106     return TRUE;
1107   if (i != 16)
1108     return FALSE;
1109
1110   if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1111     return FALSE;
1112
1113   if (CONST_STRNEQ (nextname, "__.SYMDEF       ")
1114       || CONST_STRNEQ (nextname, "__.SYMDEF/      ")) /* Old Linux archives.  */
1115     return do_slurp_bsd_armap (abfd);
1116   else if (CONST_STRNEQ (nextname, "/               "))
1117     return do_slurp_coff_armap (abfd);
1118   else if (CONST_STRNEQ (nextname, "/SYM64/         "))
1119     {
1120       /* 64bit ELF (Irix 6) archive.  */
1121 #ifdef BFD64
1122       extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *);
1123       return bfd_elf64_archive_slurp_armap (abfd);
1124 #else
1125       bfd_set_error (bfd_error_wrong_format);
1126       return FALSE;
1127 #endif
1128     }
1129   else if (CONST_STRNEQ (nextname, "#1/20           "))
1130     {
1131       /* Mach-O has a special name for armap when the map is sorted by name.
1132          However because this name has a space it is slightly more difficult
1133          to check it.  */
1134       struct ar_hdr hdr;
1135       char extname[21];
1136
1137       if (bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
1138         return FALSE;
1139       /* Read the extended name.  We know its length.  */
1140       if (bfd_bread (extname, 20, abfd) != 20)
1141         return FALSE;
1142       if (bfd_seek (abfd, -(file_ptr) (sizeof (hdr) + 20), SEEK_CUR) != 0)
1143         return FALSE;
1144       extname[20] = 0;
1145       if (CONST_STRNEQ (extname, "__.SYMDEF SORTED")
1146           || CONST_STRNEQ (extname, "__.SYMDEF"))
1147         return do_slurp_bsd_armap (abfd);
1148     }
1149
1150   bfd_has_map (abfd) = FALSE;
1151   return TRUE;
1152 }
1153 \f
1154 /* Returns FALSE on error, TRUE otherwise.  */
1155 /* Flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
1156    header is in a slightly different order and the map name is '/'.
1157    This flavour is used by hp300hpux.  */
1158
1159 #define HPUX_SYMDEF_COUNT_SIZE 2
1160
1161 bfd_boolean
1162 bfd_slurp_bsd_armap_f2 (bfd *abfd)
1163 {
1164   struct areltdata *mapdata;
1165   char nextname[17];
1166   unsigned int counter;
1167   bfd_byte *raw_armap, *rbase;
1168   struct artdata *ardata = bfd_ardata (abfd);
1169   char *stringbase;
1170   unsigned int stringsize;
1171   unsigned int left;
1172   bfd_size_type amt;
1173   carsym *set;
1174   int i = bfd_bread (nextname, 16, abfd);
1175
1176   if (i == 0)
1177     return TRUE;
1178   if (i != 16)
1179     return FALSE;
1180
1181   /* The archive has at least 16 bytes in it.  */
1182   if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1183     return FALSE;
1184
1185   if (CONST_STRNEQ (nextname, "__.SYMDEF       ")
1186       || CONST_STRNEQ (nextname, "__.SYMDEF/      ")) /* Old Linux archives.  */
1187     return do_slurp_bsd_armap (abfd);
1188
1189   if (! CONST_STRNEQ (nextname, "/               "))
1190     {
1191       bfd_has_map (abfd) = FALSE;
1192       return TRUE;
1193     }
1194
1195   mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
1196   if (mapdata == NULL)
1197     return FALSE;
1198
1199   if (mapdata->parsed_size < HPUX_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE)
1200     {
1201       free (mapdata);
1202     wrong_format:
1203       bfd_set_error (bfd_error_wrong_format);
1204     byebye:
1205       return FALSE;
1206     }
1207   left = mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE - BSD_STRING_COUNT_SIZE;
1208
1209   amt = mapdata->parsed_size;
1210   free (mapdata);
1211
1212   raw_armap = (bfd_byte *) bfd_zalloc (abfd, amt);
1213   if (raw_armap == NULL)
1214     goto byebye;
1215
1216   if (bfd_bread (raw_armap, amt, abfd) != amt)
1217     {
1218       if (bfd_get_error () != bfd_error_system_call)
1219         bfd_set_error (bfd_error_malformed_archive);
1220       goto byebye;
1221     }
1222
1223   ardata->symdef_count = H_GET_16 (abfd, raw_armap);
1224
1225   ardata->cache = 0;
1226
1227   stringsize = H_GET_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE);
1228   if (stringsize > left)
1229     goto wrong_format;
1230   left -= stringsize;
1231
1232   /* Skip sym count and string sz.  */
1233   stringbase = ((char *) raw_armap
1234                 + HPUX_SYMDEF_COUNT_SIZE
1235                 + BSD_STRING_COUNT_SIZE);
1236   rbase = (bfd_byte *) stringbase + stringsize;
1237   amt = ardata->symdef_count * BSD_SYMDEF_SIZE;
1238   if (amt > left)
1239     goto wrong_format;
1240
1241   ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt);
1242   if (!ardata->symdefs)
1243     return FALSE;
1244
1245   for (counter = 0, set = ardata->symdefs;
1246        counter < ardata->symdef_count;
1247        counter++, set++, rbase += BSD_SYMDEF_SIZE)
1248     {
1249       set->name = H_GET_32 (abfd, rbase) + stringbase;
1250       set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
1251     }
1252
1253   ardata->first_file_filepos = bfd_tell (abfd);
1254   /* Pad to an even boundary if you have to.  */
1255   ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1256   /* FIXME, we should provide some way to free raw_ardata when
1257      we are done using the strings from it.  For now, it seems
1258      to be allocated on an objalloc anyway...  */
1259   bfd_has_map (abfd) = TRUE;
1260   return TRUE;
1261 }
1262 \f
1263 /** Extended name table.
1264
1265   Normally archives support only 14-character filenames.
1266
1267   Intel has extended the format: longer names are stored in a special
1268   element (the first in the archive, or second if there is an armap);
1269   the name in the ar_hdr is replaced by <space><index into filename
1270   element>.  Index is the P.R. of an int (decimal).  Data General have
1271   extended the format by using the prefix // for the special element.  */
1272
1273 /* Returns FALSE on error, TRUE otherwise.  */
1274
1275 bfd_boolean
1276 _bfd_slurp_extended_name_table (bfd *abfd)
1277 {
1278   char nextname[17];
1279   struct areltdata *namedata;
1280   bfd_size_type amt;
1281
1282   /* FIXME:  Formatting sucks here, and in case of failure of BFD_READ,
1283      we probably don't want to return TRUE.  */
1284   if (bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET) != 0)
1285     return FALSE;
1286
1287   if (bfd_bread (nextname, 16, abfd) == 16)
1288     {
1289       if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1290         return FALSE;
1291
1292       if (! CONST_STRNEQ (nextname, "ARFILENAMES/    ")
1293           && ! CONST_STRNEQ (nextname, "//              "))
1294         {
1295           bfd_ardata (abfd)->extended_names = NULL;
1296           bfd_ardata (abfd)->extended_names_size = 0;
1297           return TRUE;
1298         }
1299
1300       namedata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
1301       if (namedata == NULL)
1302         return FALSE;
1303
1304       amt = namedata->parsed_size;
1305       if (amt + 1 == 0)
1306         goto byebye;
1307
1308       bfd_ardata (abfd)->extended_names_size = amt;
1309       bfd_ardata (abfd)->extended_names = (char *) bfd_zalloc (abfd, amt + 1);
1310       if (bfd_ardata (abfd)->extended_names == NULL)
1311         {
1312         byebye:
1313           free (namedata);
1314           bfd_ardata (abfd)->extended_names = NULL;
1315           bfd_ardata (abfd)->extended_names_size = 0;
1316           return FALSE;
1317         }
1318
1319       if (bfd_bread (bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
1320         {
1321           if (bfd_get_error () != bfd_error_system_call)
1322             bfd_set_error (bfd_error_malformed_archive);
1323           bfd_release (abfd, (bfd_ardata (abfd)->extended_names));
1324           bfd_ardata (abfd)->extended_names = NULL;
1325           goto byebye;
1326         }
1327
1328       /* Since the archive is supposed to be printable if it contains
1329          text, the entries in the list are newline-padded, not null
1330          padded. In SVR4-style archives, the names also have a
1331          trailing '/'.  DOS/NT created archive often have \ in them
1332          We'll fix all problems here.  */
1333       {
1334         char *ext_names = bfd_ardata (abfd)->extended_names;
1335         char *temp = ext_names;
1336         char *limit = temp + namedata->parsed_size;
1337
1338         for (; temp < limit; ++temp)
1339           {
1340             if (*temp == ARFMAG[1])
1341               temp[temp > ext_names && temp[-1] == '/' ? -1 : 0] = '\0';
1342             if (*temp == '\\')
1343               *temp = '/';
1344           }
1345         *limit = '\0';
1346       }
1347
1348       /* Pad to an even boundary if you have to.  */
1349       bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd);
1350       bfd_ardata (abfd)->first_file_filepos +=
1351         (bfd_ardata (abfd)->first_file_filepos) % 2;
1352
1353       free (namedata);
1354     }
1355   return TRUE;
1356 }
1357
1358 #ifdef VMS
1359
1360 /* Return a copy of the stuff in the filename between any :]> and a
1361    semicolon.  */
1362
1363 static const char *
1364 normalize (bfd *abfd, const char *file)
1365 {
1366   const char *first;
1367   const char *last;
1368   char *copy;
1369
1370   first = file + strlen (file) - 1;
1371   last = first + 1;
1372
1373   while (first != file)
1374     {
1375       if (*first == ';')
1376         last = first;
1377       if (*first == ':' || *first == ']' || *first == '>')
1378         {
1379           first++;
1380           break;
1381         }
1382       first--;
1383     }
1384
1385   copy = bfd_alloc (abfd, last - first + 1);
1386   if (copy == NULL)
1387     return NULL;
1388
1389   memcpy (copy, first, last - first);
1390   copy[last - first] = 0;
1391
1392   return copy;
1393 }
1394
1395 #else
1396 static const char *
1397 normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file)
1398 {
1399   return lbasename (file);
1400 }
1401 #endif
1402
1403 /* Adjust a relative path name based on the reference path.
1404    For example:
1405
1406      Relative path  Reference path  Result
1407      -------------  --------------  ------
1408      bar.o          lib.a           bar.o
1409      foo/bar.o      lib.a           foo/bar.o
1410      bar.o          foo/lib.a       ../bar.o
1411      foo/bar.o      baz/lib.a       ../foo/bar.o
1412      bar.o          ../lib.a        <parent of current dir>/bar.o
1413    ; ../bar.o       ../lib.a        bar.o
1414    ; ../bar.o       lib.a           ../bar.o
1415      foo/bar.o      ../lib.a        <parent of current dir>/foo/bar.o
1416      bar.o          ../../lib.a     <grandparent>/<parent>/bar.o
1417      bar.o          foo/baz/lib.a   ../../bar.o
1418
1419    Note - the semicolons above are there to prevent the BFD chew
1420    utility from interpreting those lines as prototypes to put into
1421    the autogenerated bfd.h header...
1422
1423    Note - the string is returned in a static buffer.  */
1424
1425 static const char *
1426 adjust_relative_path (const char * path, const char * ref_path)
1427 {
1428   static char *pathbuf = NULL;
1429   static unsigned int pathbuf_len = 0;
1430   const char *pathp;
1431   const char *refp;
1432   char * lpath;
1433   char * rpath;
1434   unsigned int len;
1435   unsigned int dir_up = 0;
1436   unsigned int dir_down = 0;
1437   char *newp;
1438   char * pwd = getpwd ();
1439   const char * down;
1440
1441   /* Remove symlinks, '.' and '..' from the paths, if possible.  */
1442   lpath = lrealpath (path);
1443   pathp = lpath == NULL ? path : lpath;
1444
1445   rpath = lrealpath (ref_path);
1446   refp = rpath == NULL ? ref_path : rpath;
1447
1448   /* Remove common leading path elements.  */
1449   for (;;)
1450     {
1451       const char *e1 = pathp;
1452       const char *e2 = refp;
1453
1454       while (*e1 && ! IS_DIR_SEPARATOR (*e1))
1455         ++e1;
1456       while (*e2 && ! IS_DIR_SEPARATOR (*e2))
1457         ++e2;
1458       if (*e1 == '\0' || *e2 == '\0' || e1 - pathp != e2 - refp
1459           || filename_ncmp (pathp, refp, e1 - pathp) != 0)
1460         break;
1461       pathp = e1 + 1;
1462       refp = e2 + 1;
1463     }
1464
1465   len = strlen (pathp) + 1;
1466   /* For each leading path element in the reference path,
1467      insert "../" into the path.  */
1468   for (; *refp; ++refp)
1469     if (IS_DIR_SEPARATOR (*refp))
1470       {
1471         /* PR 12710:  If the path element is "../" then instead of
1472            inserting "../" we need to insert the name of the directory
1473            at the current level.  */
1474         if (refp > ref_path + 1
1475             && refp[-1] == '.'
1476             && refp[-2] == '.')
1477           dir_down ++;
1478         else
1479           dir_up ++;
1480       }
1481
1482   /* If the lrealpath calls above succeeded then we should never
1483      see dir_up and dir_down both being non-zero.  */
1484
1485   len += 3 * dir_up;
1486
1487   if (dir_down)
1488     {
1489       down = pwd + strlen (pwd) - 1;
1490
1491       while (dir_down && down > pwd)
1492         {
1493           if (IS_DIR_SEPARATOR (*down))
1494             --dir_down;
1495         }
1496       BFD_ASSERT (dir_down == 0);
1497       len += strlen (down) + 1;
1498     }
1499   else
1500     down = NULL;
1501
1502   if (len > pathbuf_len)
1503     {
1504       if (pathbuf != NULL)
1505         free (pathbuf);
1506       pathbuf_len = 0;
1507       pathbuf = (char *) bfd_malloc (len);
1508       if (pathbuf == NULL)
1509         goto out;
1510       pathbuf_len = len;
1511     }
1512
1513   newp = pathbuf;
1514   while (dir_up-- > 0)
1515     {
1516       /* FIXME: Support Windows style path separators as well.  */
1517       strcpy (newp, "../");
1518       newp += 3;
1519     }
1520
1521   if (down)
1522     sprintf (newp, "%s/%s", down, pathp);
1523   else
1524     strcpy (newp, pathp);
1525
1526  out:
1527   free (lpath);
1528   free (rpath);
1529   return pathbuf;
1530 }
1531
1532 /* Build a BFD style extended name table.  */
1533
1534 bfd_boolean
1535 _bfd_archive_bsd_construct_extended_name_table (bfd *abfd,
1536                                                 char **tabloc,
1537                                                 bfd_size_type *tablen,
1538                                                 const char **name)
1539 {
1540   *name = "ARFILENAMES/";
1541   return _bfd_construct_extended_name_table (abfd, FALSE, tabloc, tablen);
1542 }
1543
1544 /* Build an SVR4 style extended name table.  */
1545
1546 bfd_boolean
1547 _bfd_archive_coff_construct_extended_name_table (bfd *abfd,
1548                                                  char **tabloc,
1549                                                  bfd_size_type *tablen,
1550                                                  const char **name)
1551 {
1552   *name = "//";
1553   return _bfd_construct_extended_name_table (abfd, TRUE, tabloc, tablen);
1554 }
1555
1556 /* Follows archive_head and produces an extended name table if
1557    necessary.  Returns (in tabloc) a pointer to an extended name
1558    table, and in tablen the length of the table.  If it makes an entry
1559    it clobbers the filename so that the element may be written without
1560    further massage.  Returns TRUE if it ran successfully, FALSE if
1561    something went wrong.  A successful return may still involve a
1562    zero-length tablen!  */
1563
1564 bfd_boolean
1565 _bfd_construct_extended_name_table (bfd *abfd,
1566                                     bfd_boolean trailing_slash,
1567                                     char **tabloc,
1568                                     bfd_size_type *tablen)
1569 {
1570   unsigned int maxname = ar_maxnamelen (abfd);
1571   bfd_size_type total_namelen = 0;
1572   bfd *current;
1573   char *strptr;
1574   const char *last_filename;
1575   long last_stroff;
1576
1577   *tablen = 0;
1578   last_filename = NULL;
1579
1580   /* Figure out how long the table should be.  */
1581   for (current = abfd->archive_head;
1582        current != NULL;
1583        current = current->archive_next)
1584     {
1585       const char *normal;
1586       unsigned int thislen;
1587
1588       if (bfd_is_thin_archive (abfd))
1589         {
1590           const char *filename = current->filename;
1591
1592           /* If the element being added is a member of another archive
1593              (i.e., we are flattening), use the containing archive's name.  */
1594           if (current->my_archive
1595               && ! bfd_is_thin_archive (current->my_archive))
1596             filename = current->my_archive->filename;
1597
1598           /* If the path is the same as the previous path seen,
1599              reuse it.  This can happen when flattening a thin
1600              archive that contains other archives.  */
1601           if (last_filename && filename_cmp (last_filename, filename) == 0)
1602             continue;
1603
1604           last_filename = filename;
1605
1606           /* If the path is relative, adjust it relative to
1607              the containing archive. */
1608           if (! IS_ABSOLUTE_PATH (filename)
1609               && ! IS_ABSOLUTE_PATH (abfd->filename))
1610             normal = adjust_relative_path (filename, abfd->filename);
1611           else
1612             normal = filename;
1613
1614           /* In a thin archive, always store the full pathname
1615              in the extended name table.  */
1616           total_namelen += strlen (normal) + 1;
1617           if (trailing_slash)
1618             /* Leave room for trailing slash.  */
1619             ++total_namelen;
1620
1621           continue;
1622         }
1623
1624       normal = normalize (current, current->filename);
1625       if (normal == NULL)
1626         return FALSE;
1627
1628       thislen = strlen (normal);
1629
1630       if (thislen > maxname
1631           && (bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1632         thislen = maxname;
1633
1634       if (thislen > maxname)
1635         {
1636           /* Add one to leave room for \n.  */
1637           total_namelen += thislen + 1;
1638           if (trailing_slash)
1639             {
1640               /* Leave room for trailing slash.  */
1641               ++total_namelen;
1642             }
1643         }
1644       else
1645         {
1646           struct ar_hdr *hdr = arch_hdr (current);
1647           if (filename_ncmp (normal, hdr->ar_name, thislen) != 0
1648               || (thislen < sizeof hdr->ar_name
1649                   && hdr->ar_name[thislen] != ar_padchar (current)))
1650             {
1651               /* Must have been using extended format even though it
1652                  didn't need to.  Fix it to use normal format.  */
1653               memcpy (hdr->ar_name, normal, thislen);
1654               if (thislen < maxname
1655                   || (thislen == maxname && thislen < sizeof hdr->ar_name))
1656                 hdr->ar_name[thislen] = ar_padchar (current);
1657             }
1658         }
1659     }
1660
1661   if (total_namelen == 0)
1662     return TRUE;
1663
1664   *tabloc = (char *) bfd_zalloc (abfd, total_namelen);
1665   if (*tabloc == NULL)
1666     return FALSE;
1667
1668   *tablen = total_namelen;
1669   strptr = *tabloc;
1670
1671   last_filename = NULL;
1672   last_stroff = 0;
1673
1674   for (current = abfd->archive_head;
1675        current != NULL;
1676        current = current->archive_next)
1677     {
1678       const char *normal;
1679       unsigned int thislen;
1680       long stroff;
1681       const char *filename = current->filename;
1682
1683       if (bfd_is_thin_archive (abfd))
1684         {
1685           /* If the element being added is a member of another archive
1686              (i.e., we are flattening), use the containing archive's name.  */
1687           if (current->my_archive
1688               && ! bfd_is_thin_archive (current->my_archive))
1689             filename = current->my_archive->filename;
1690           /* If the path is the same as the previous path seen,
1691              reuse it.  This can happen when flattening a thin
1692              archive that contains other archives.
1693              If the path is relative, adjust it relative to
1694              the containing archive.  */
1695           if (last_filename && filename_cmp (last_filename, filename) == 0)
1696             normal = last_filename;
1697           else if (! IS_ABSOLUTE_PATH (filename)
1698                    && ! IS_ABSOLUTE_PATH (abfd->filename))
1699             normal = adjust_relative_path (filename, abfd->filename);
1700           else
1701             normal = filename;
1702         }
1703       else
1704         {
1705           normal = normalize (current, filename);
1706           if (normal == NULL)
1707             return FALSE;
1708         }
1709
1710       thislen = strlen (normal);
1711       if (thislen > maxname || bfd_is_thin_archive (abfd))
1712         {
1713           /* Works for now; may need to be re-engineered if we
1714              encounter an oddball archive format and want to
1715              generalise this hack.  */
1716           struct ar_hdr *hdr = arch_hdr (current);
1717           if (normal == last_filename)
1718             stroff = last_stroff;
1719           else
1720             {
1721               strcpy (strptr, normal);
1722               if (! trailing_slash)
1723                 strptr[thislen] = ARFMAG[1];
1724               else
1725                 {
1726                   strptr[thislen] = '/';
1727                   strptr[thislen + 1] = ARFMAG[1];
1728                 }
1729               stroff = strptr - *tabloc;
1730               last_stroff = stroff;
1731             }
1732           hdr->ar_name[0] = ar_padchar (current);
1733           if (bfd_is_thin_archive (abfd) && current->origin > 0)
1734             {
1735               int len = snprintf (hdr->ar_name + 1, maxname - 1, "%-ld:",
1736                                   stroff);
1737               _bfd_ar_spacepad (hdr->ar_name + 1 + len, maxname - 1 - len,
1738                                 "%-ld",
1739                                 current->origin - sizeof (struct ar_hdr));
1740             }
1741           else
1742             _bfd_ar_spacepad (hdr->ar_name + 1, maxname - 1, "%-ld", stroff);
1743           if (normal != last_filename)
1744             {
1745               strptr += thislen + 1;
1746               if (trailing_slash)
1747                 ++strptr;
1748               last_filename = filename;
1749             }
1750         }
1751     }
1752
1753   return TRUE;
1754 }
1755
1756 /* Do not construct an extended name table but transforms name field into
1757    its extended form.  */
1758
1759 bfd_boolean
1760 _bfd_archive_bsd44_construct_extended_name_table (bfd *abfd,
1761                                                   char **tabloc,
1762                                                   bfd_size_type *tablen,
1763                                                   const char **name)
1764 {
1765   unsigned int maxname = ar_maxnamelen (abfd);
1766   bfd *current;
1767
1768   *tablen = 0;
1769   *tabloc = NULL;
1770   *name = NULL;
1771
1772   for (current = abfd->archive_head;
1773        current != NULL;
1774        current = current->archive_next)
1775     {
1776       const char *normal = normalize (current, current->filename);
1777       int has_space = 0;
1778       unsigned int len;
1779
1780       if (normal == NULL)
1781         return FALSE;
1782
1783       for (len = 0; normal[len]; len++)
1784         if (normal[len] == ' ')
1785           has_space = 1;
1786
1787       if (len > maxname || has_space)
1788         {
1789           struct ar_hdr *hdr = arch_hdr (current);
1790
1791           len = (len + 3) & ~3;
1792           arch_eltdata (current)->extra_size = len;
1793           _bfd_ar_spacepad (hdr->ar_name, maxname, "#1/%lu", len);
1794         }
1795     }
1796
1797   return TRUE;
1798 }
1799 \f
1800 /* Write an archive header.  */
1801
1802 bfd_boolean
1803 _bfd_generic_write_ar_hdr (bfd *archive, bfd *abfd)
1804 {
1805   struct ar_hdr *hdr = arch_hdr (abfd);
1806
1807   if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
1808     return FALSE;
1809   return TRUE;
1810 }
1811
1812 /* Write an archive header using BSD4.4 convention.  */
1813
1814 bfd_boolean
1815 _bfd_bsd44_write_ar_hdr (bfd *archive, bfd *abfd)
1816 {
1817   struct ar_hdr *hdr = arch_hdr (abfd);
1818
1819   if (is_bsd44_extended_name (hdr->ar_name))
1820     {
1821       /* This is a BSD 4.4 extended name.  */
1822       const char *fullname = normalize (abfd, abfd->filename);
1823       unsigned int len = strlen (fullname);
1824       unsigned int padded_len = (len + 3) & ~3;
1825
1826       BFD_ASSERT (padded_len == arch_eltdata (abfd)->extra_size);
1827
1828       if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size),
1829                             arch_eltdata (abfd)->parsed_size + padded_len))
1830         return FALSE;
1831
1832       if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
1833         return FALSE;
1834
1835       if (bfd_bwrite (fullname, len, archive) != len)
1836         return FALSE;
1837
1838       if (len & 3)
1839         {
1840           static const char pad[3] = { 0, 0, 0 };
1841
1842           len = 4 - (len & 3);
1843           if (bfd_bwrite (pad, len, archive) != len)
1844             return FALSE;
1845         }
1846     }
1847   else
1848     {
1849       if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
1850         return FALSE;
1851     }
1852   return TRUE;
1853 }
1854 \f
1855 /* A couple of functions for creating ar_hdrs.  */
1856
1857 #ifdef HPUX_LARGE_AR_IDS
1858 /* Function to encode large UID/GID values according to HP.  */
1859
1860 static void
1861 hpux_uid_gid_encode (char str[6], long int id)
1862 {
1863   int cnt;
1864
1865   str[5] = '@' + (id & 3);
1866   id >>= 2;
1867
1868   for (cnt = 4; cnt >= 0; --cnt, id >>= 6)
1869     str[cnt] = ' ' + (id & 0x3f);
1870 }
1871 #endif  /* HPUX_LARGE_AR_IDS */
1872
1873 #ifndef HAVE_GETUID
1874 #define getuid() 0
1875 #endif
1876
1877 #ifndef HAVE_GETGID
1878 #define getgid() 0
1879 #endif
1880
1881 /* Takes a filename, returns an arelt_data for it, or NULL if it can't
1882    make one.  The filename must refer to a filename in the filesystem.
1883    The filename field of the ar_hdr will NOT be initialized.  If member
1884    is set, and it's an in-memory bfd, we fake it.  */
1885
1886 static struct areltdata *
1887 bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
1888 {
1889   struct stat status;
1890   struct areltdata *ared;
1891   struct ar_hdr *hdr;
1892   bfd_size_type amt;
1893
1894   if (member && (member->flags & BFD_IN_MEMORY) != 0)
1895     {
1896       /* Assume we just "made" the member, and fake it.  */
1897       struct bfd_in_memory *bim = (struct bfd_in_memory *) member->iostream;
1898       time (&status.st_mtime);
1899       status.st_uid = getuid ();
1900       status.st_gid = getgid ();
1901       status.st_mode = 0644;
1902       status.st_size = bim->size;
1903     }
1904   else if (stat (filename, &status) != 0)
1905     {
1906       bfd_set_error (bfd_error_system_call);
1907       return NULL;
1908     }
1909
1910   /* If the caller requested that the BFD generate deterministic output,
1911      fake values for modification time, UID, GID, and file mode.  */
1912   if ((abfd->flags & BFD_DETERMINISTIC_OUTPUT) != 0)
1913     {
1914       status.st_mtime = 0;
1915       status.st_uid = 0;
1916       status.st_gid = 0;
1917       status.st_mode = 0644;
1918     }
1919
1920   amt = sizeof (struct ar_hdr) + sizeof (struct areltdata);
1921   ared = (struct areltdata *) bfd_zmalloc (amt);
1922   if (ared == NULL)
1923     return NULL;
1924   hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));
1925
1926   /* ar headers are space padded, not null padded!  */
1927   memset (hdr, ' ', sizeof (struct ar_hdr));
1928
1929   _bfd_ar_spacepad (hdr->ar_date, sizeof (hdr->ar_date), "%-12ld",
1930                     status.st_mtime);
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_uid > 99999)
1935     hpux_uid_gid_encode (hdr->ar_uid, (long) status.st_uid);
1936   else
1937 #endif
1938     _bfd_ar_spacepad (hdr->ar_uid, sizeof (hdr->ar_uid), "%ld",
1939                       status.st_uid);
1940 #ifdef HPUX_LARGE_AR_IDS
1941   /* HP has a very "special" way to handle UID/GID's with numeric values
1942      > 99999.  */
1943   if (status.st_gid > 99999)
1944     hpux_uid_gid_encode (hdr->ar_gid, (long) status.st_gid);
1945   else
1946 #endif
1947     _bfd_ar_spacepad (hdr->ar_gid, sizeof (hdr->ar_gid), "%ld",
1948                       status.st_gid);
1949   _bfd_ar_spacepad (hdr->ar_mode, sizeof (hdr->ar_mode), "%-8lo",
1950                     status.st_mode);
1951   if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size), status.st_size))
1952     {
1953       free (ared);
1954       return NULL;
1955     }
1956   memcpy (hdr->ar_fmag, ARFMAG, 2);
1957   ared->parsed_size = status.st_size;
1958   ared->arch_header = (char *) hdr;
1959
1960   return ared;
1961 }
1962
1963 /* Analogous to stat call.  */
1964
1965 int
1966 bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
1967 {
1968   struct ar_hdr *hdr;
1969   char *aloser;
1970
1971   if (abfd->arelt_data == NULL)
1972     {
1973       bfd_set_error (bfd_error_invalid_operation);
1974       return -1;
1975     }
1976
1977   hdr = arch_hdr (abfd);
1978   /* PR 17512: file: 3d9e9fe9.  */
1979   if (hdr == NULL)
1980     return -1;
1981 #define foo(arelt, stelt, size)                         \
1982   buf->stelt = strtol (hdr->arelt, &aloser, size);      \
1983   if (aloser == hdr->arelt)                             \
1984     return -1;
1985
1986   /* Some platforms support special notations for large IDs.  */
1987 #ifdef HPUX_LARGE_AR_IDS
1988 # define foo2(arelt, stelt, size)                                       \
1989   if (hdr->arelt[5] == ' ')                                             \
1990     {                                                                   \
1991       foo (arelt, stelt, size);                                         \
1992     }                                                                   \
1993   else                                                                  \
1994     {                                                                   \
1995       int cnt;                                                          \
1996       for (buf->stelt = cnt = 0; cnt < 5; ++cnt)                        \
1997         {                                                               \
1998           if (hdr->arelt[cnt] < ' ' || hdr->arelt[cnt] > ' ' + 0x3f)    \
1999             return -1;                                                  \
2000           buf->stelt <<= 6;                                             \
2001           buf->stelt += hdr->arelt[cnt] - ' ';                          \
2002         }                                                               \
2003       if (hdr->arelt[5] < '@' || hdr->arelt[5] > '@' + 3)               \
2004         return -1;                                                      \
2005       buf->stelt <<= 2;                                                 \
2006       buf->stelt += hdr->arelt[5] - '@';                                \
2007     }
2008 #else
2009 # define foo2(arelt, stelt, size) foo (arelt, stelt, size)
2010 #endif
2011
2012   foo (ar_date, st_mtime, 10);
2013   foo2 (ar_uid, st_uid, 10);
2014   foo2 (ar_gid, st_gid, 10);
2015   foo (ar_mode, st_mode, 8);
2016
2017   buf->st_size = arch_eltdata (abfd)->parsed_size;
2018
2019   return 0;
2020 }
2021
2022 void
2023 bfd_dont_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
2024 {
2025   /* FIXME: This interacts unpleasantly with ar's quick-append option.
2026      Fortunately ic960 users will never use that option.  Fixing this
2027      is very hard; fortunately I know how to do it and will do so once
2028      intel's release is out the door.  */
2029
2030   struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
2031   size_t length;
2032   const char *filename;
2033   size_t maxlen = ar_maxnamelen (abfd);
2034
2035   if ((bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
2036     {
2037       bfd_bsd_truncate_arname (abfd, pathname, arhdr);
2038       return;
2039     }
2040
2041   filename = normalize (abfd, pathname);
2042   if (filename == NULL)
2043     {
2044       /* FIXME */
2045       abort ();
2046     }
2047
2048   length = strlen (filename);
2049
2050   if (length <= maxlen)
2051     memcpy (hdr->ar_name, filename, length);
2052
2053   /* Add the padding character if there is room for it.  */
2054   if (length < maxlen
2055       || (length == maxlen && length < sizeof hdr->ar_name))
2056     (hdr->ar_name)[length] = ar_padchar (abfd);
2057 }
2058
2059 void
2060 bfd_bsd_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
2061 {
2062   struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
2063   size_t length;
2064   const char *filename = lbasename (pathname);
2065   size_t maxlen = ar_maxnamelen (abfd);
2066
2067   length = strlen (filename);
2068
2069   if (length <= maxlen)
2070     memcpy (hdr->ar_name, filename, length);
2071   else
2072     {
2073       /* pathname: meet procrustes */
2074       memcpy (hdr->ar_name, filename, maxlen);
2075       length = maxlen;
2076     }
2077
2078   if (length < maxlen)
2079     (hdr->ar_name)[length] = ar_padchar (abfd);
2080 }
2081
2082 /* Store name into ar header.  Truncates the name to fit.
2083    1> strip pathname to be just the basename.
2084    2> if it's short enuf to fit, stuff it in.
2085    3> If it doesn't end with .o, truncate it to fit
2086    4> truncate it before the .o, append .o, stuff THAT in.  */
2087
2088 /* This is what gnu ar does.  It's better but incompatible with the
2089    bsd ar.  */
2090
2091 void
2092 bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
2093 {
2094   struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
2095   size_t length;
2096   const char *filename = lbasename (pathname);
2097   size_t maxlen = ar_maxnamelen (abfd);
2098
2099   length = strlen (filename);
2100
2101   if (length <= maxlen)
2102     memcpy (hdr->ar_name, filename, length);
2103   else
2104     {
2105       /* pathname: meet procrustes.  */
2106       memcpy (hdr->ar_name, filename, maxlen);
2107       if ((filename[length - 2] == '.') && (filename[length - 1] == 'o'))
2108         {
2109           hdr->ar_name[maxlen - 2] = '.';
2110           hdr->ar_name[maxlen - 1] = 'o';
2111         }
2112       length = maxlen;
2113     }
2114
2115   if (length < 16)
2116     (hdr->ar_name)[length] = ar_padchar (abfd);
2117 }
2118 \f
2119 /* The BFD is open for write and has its format set to bfd_archive.  */
2120
2121 bfd_boolean
2122 _bfd_write_archive_contents (bfd *arch)
2123 {
2124   bfd *current;
2125   char *etable = NULL;
2126   bfd_size_type elength = 0;
2127   const char *ename = NULL;
2128   bfd_boolean makemap = bfd_has_map (arch);
2129   /* If no .o's, don't bother to make a map.  */
2130   bfd_boolean hasobjects = FALSE;
2131   bfd_size_type wrote;
2132   int tries;
2133   char *armag;
2134
2135   /* Verify the viability of all entries; if any of them live in the
2136      filesystem (as opposed to living in an archive open for input)
2137      then construct a fresh ar_hdr for them.  */
2138   for (current = arch->archive_head;
2139        current != NULL;
2140        current = current->archive_next)
2141     {
2142       /* This check is checking the bfds for the objects we're reading
2143          from (which are usually either an object file or archive on
2144          disk), not the archive entries we're writing to.  We don't
2145          actually create bfds for the archive members, we just copy
2146          them byte-wise when we write out the archive.  */
2147       if (bfd_write_p (current))
2148         {
2149           bfd_set_error (bfd_error_invalid_operation);
2150           goto input_err;
2151         }
2152       if (!current->arelt_data)
2153         {
2154           current->arelt_data =
2155             bfd_ar_hdr_from_filesystem (arch, current->filename, current);
2156           if (!current->arelt_data)
2157             goto input_err;
2158
2159           /* Put in the file name.  */
2160           BFD_SEND (arch, _bfd_truncate_arname,
2161                     (arch, current->filename, (char *) arch_hdr (current)));
2162         }
2163
2164       if (makemap && ! hasobjects)
2165         {                       /* Don't bother if we won't make a map!  */
2166           if ((bfd_check_format (current, bfd_object)))
2167             hasobjects = TRUE;
2168         }
2169     }
2170
2171   if (!BFD_SEND (arch, _bfd_construct_extended_name_table,
2172                  (arch, &etable, &elength, &ename)))
2173     return FALSE;
2174
2175   if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0)
2176     return FALSE;
2177   armag = ARMAG;
2178   if (bfd_is_thin_archive (arch))
2179     armag = ARMAGT;
2180   wrote = bfd_bwrite (armag, SARMAG, arch);
2181   if (wrote != SARMAG)
2182     return FALSE;
2183
2184   if (makemap && hasobjects)
2185     {
2186       if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength))
2187         return FALSE;
2188     }
2189
2190   if (elength != 0)
2191     {
2192       struct ar_hdr hdr;
2193
2194       memset (&hdr, ' ', sizeof (struct ar_hdr));
2195       memcpy (hdr.ar_name, ename, strlen (ename));
2196       /* Round size up to even number in archive header.  */
2197       if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size),
2198                             (elength + 1) & ~(bfd_size_type) 1))
2199         return FALSE;
2200       memcpy (hdr.ar_fmag, ARFMAG, 2);
2201       if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2202            != sizeof (struct ar_hdr))
2203           || bfd_bwrite (etable, elength, arch) != elength)
2204         return FALSE;
2205       if ((elength % 2) == 1)
2206         {
2207           if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)
2208             return FALSE;
2209         }
2210     }
2211
2212   for (current = arch->archive_head;
2213        current != NULL;
2214        current = current->archive_next)
2215     {
2216       char buffer[DEFAULT_BUFFERSIZE];
2217       bfd_size_type remaining = arelt_size (current);
2218
2219       /* Write ar header.  */
2220       if (!_bfd_write_ar_hdr (arch, current))
2221         return FALSE;
2222       if (bfd_is_thin_archive (arch))
2223         continue;
2224       if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
2225         goto input_err;
2226
2227       while (remaining)
2228         {
2229           unsigned int amt = DEFAULT_BUFFERSIZE;
2230
2231           if (amt > remaining)
2232             amt = remaining;
2233           errno = 0;
2234           if (bfd_bread (buffer, amt, current) != amt)
2235             {
2236               if (bfd_get_error () != bfd_error_system_call)
2237                 bfd_set_error (bfd_error_file_truncated);
2238               goto input_err;
2239             }
2240           if (bfd_bwrite (buffer, amt, arch) != amt)
2241             return FALSE;
2242           remaining -= amt;
2243         }
2244
2245       if ((arelt_size (current) % 2) == 1)
2246         {
2247           if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)
2248             return FALSE;
2249         }
2250     }
2251
2252   if (makemap && hasobjects)
2253     {
2254       /* Verify the timestamp in the archive file.  If it would not be
2255          accepted by the linker, rewrite it until it would be.  If
2256          anything odd happens, break out and just return.  (The
2257          Berkeley linker checks the timestamp and refuses to read the
2258          table-of-contents if it is >60 seconds less than the file's
2259          modified-time.  That painful hack requires this painful hack.  */
2260       tries = 1;
2261       do
2262         {
2263           if (bfd_update_armap_timestamp (arch))
2264             break;
2265           (*_bfd_error_handler)
2266             (_("Warning: writing archive was slow: rewriting timestamp\n"));
2267         }
2268       while (++tries < 6);
2269     }
2270
2271   return TRUE;
2272
2273  input_err:
2274   bfd_set_error (bfd_error_on_input, current, bfd_get_error ());
2275   return FALSE;
2276 }
2277 \f
2278 /* Note that the namidx for the first symbol is 0.  */
2279
2280 bfd_boolean
2281 _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
2282 {
2283   char *first_name = NULL;
2284   bfd *current;
2285   file_ptr elt_no = 0;
2286   struct orl *map = NULL;
2287   unsigned int orl_max = 1024;          /* Fine initial default.  */
2288   unsigned int orl_count = 0;
2289   int stridx = 0;
2290   asymbol **syms = NULL;
2291   long syms_max = 0;
2292   bfd_boolean ret;
2293   bfd_size_type amt;
2294
2295   /* Dunno if this is the best place for this info...  */
2296   if (elength != 0)
2297     elength += sizeof (struct ar_hdr);
2298   elength += elength % 2;
2299
2300   amt = orl_max * sizeof (struct orl);
2301   map = (struct orl *) bfd_malloc (amt);
2302   if (map == NULL)
2303     goto error_return;
2304
2305   /* We put the symbol names on the arch objalloc, and then discard
2306      them when done.  */
2307   first_name = (char *) bfd_alloc (arch, 1);
2308   if (first_name == NULL)
2309     goto error_return;
2310
2311   /* Drop all the files called __.SYMDEF, we're going to make our own.  */
2312   while (arch->archive_head
2313          && strcmp (arch->archive_head->filename, "__.SYMDEF") == 0)
2314     arch->archive_head = arch->archive_head->archive_next;
2315
2316   /* Map over each element.  */
2317   for (current = arch->archive_head;
2318        current != NULL;
2319        current = current->archive_next, elt_no++)
2320     {
2321       if (bfd_check_format (current, bfd_object)
2322           && (bfd_get_file_flags (current) & HAS_SYMS) != 0)
2323         {
2324           long storage;
2325           long symcount;
2326           long src_count;
2327
2328           storage = bfd_get_symtab_upper_bound (current);
2329           if (storage < 0)
2330             goto error_return;
2331
2332           if (storage != 0)
2333             {
2334               if (storage > syms_max)
2335                 {
2336                   if (syms_max > 0)
2337                     free (syms);
2338                   syms_max = storage;
2339                   syms = (asymbol **) bfd_malloc (syms_max);
2340                   if (syms == NULL)
2341                     goto error_return;
2342                 }
2343               symcount = bfd_canonicalize_symtab (current, syms);
2344               if (symcount < 0)
2345                 goto error_return;
2346
2347               /* Now map over all the symbols, picking out the ones we
2348                  want.  */
2349               for (src_count = 0; src_count < symcount; src_count++)
2350                 {
2351                   flagword flags = (syms[src_count])->flags;
2352                   asection *sec = syms[src_count]->section;
2353
2354                   if (((flags & (BSF_GLOBAL
2355                                  | BSF_WEAK
2356                                  | BSF_INDIRECT
2357                                  | BSF_GNU_UNIQUE)) != 0
2358                        || bfd_is_com_section (sec))
2359                       && ! bfd_is_und_section (sec))
2360                     {
2361                       bfd_size_type namelen;
2362                       struct orl *new_map;
2363
2364                       /* This symbol will go into the archive header.  */
2365                       if (orl_count == orl_max)
2366                         {
2367                           orl_max *= 2;
2368                           amt = orl_max * sizeof (struct orl);
2369                           new_map = (struct orl *) bfd_realloc (map, amt);
2370                           if (new_map == NULL)
2371                             goto error_return;
2372
2373                           map = new_map;
2374                         }
2375
2376                       if (strcmp (syms[src_count]->name, "__gnu_lto_slim") == 0)
2377                         (*_bfd_error_handler)
2378                           (_("%s: plugin needed to handle lto object"),
2379                            bfd_get_filename (current));
2380                       namelen = strlen (syms[src_count]->name);
2381                       amt = sizeof (char *);
2382                       map[orl_count].name = (char **) bfd_alloc (arch, amt);
2383                       if (map[orl_count].name == NULL)
2384                         goto error_return;
2385                       *(map[orl_count].name) = (char *) bfd_alloc (arch,
2386                                                                    namelen + 1);
2387                       if (*(map[orl_count].name) == NULL)
2388                         goto error_return;
2389                       strcpy (*(map[orl_count].name), syms[src_count]->name);
2390                       map[orl_count].u.abfd = current;
2391                       map[orl_count].namidx = stridx;
2392
2393                       stridx += namelen + 1;
2394                       ++orl_count;
2395                     }
2396                 }
2397             }
2398
2399           /* Now ask the BFD to free up any cached information, so we
2400              don't fill all of memory with symbol tables.  */
2401           if (! bfd_free_cached_info (current))
2402             goto error_return;
2403         }
2404     }
2405
2406   /* OK, now we have collected all the data, let's write them out.  */
2407   ret = BFD_SEND (arch, write_armap,
2408                   (arch, elength, map, orl_count, stridx));
2409
2410   if (syms_max > 0)
2411     free (syms);
2412   if (map != NULL)
2413     free (map);
2414   if (first_name != NULL)
2415     bfd_release (arch, first_name);
2416
2417   return ret;
2418
2419  error_return:
2420   if (syms_max > 0)
2421     free (syms);
2422   if (map != NULL)
2423     free (map);
2424   if (first_name != NULL)
2425     bfd_release (arch, first_name);
2426
2427   return FALSE;
2428 }
2429
2430 bfd_boolean
2431 bsd_write_armap (bfd *arch,
2432                  unsigned int elength,
2433                  struct orl *map,
2434                  unsigned int orl_count,
2435                  int stridx)
2436 {
2437   int padit = stridx & 1;
2438   unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE;
2439   unsigned int stringsize = stridx + padit;
2440   /* Include 8 bytes to store ranlibsize and stringsize in output.  */
2441   unsigned int mapsize = ranlibsize + stringsize + 8;
2442   file_ptr firstreal;
2443   bfd *current = arch->archive_head;
2444   bfd *last_elt = current;      /* Last element arch seen.  */
2445   bfd_byte temp[4];
2446   unsigned int count;
2447   struct ar_hdr hdr;
2448   long uid, gid;
2449
2450   firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
2451
2452   /* If deterministic, we use 0 as the timestamp in the map.
2453      Some linkers may require that the archive filesystem modification
2454      time is less than (or near to) the archive map timestamp.  Those
2455      linkers should not be used with deterministic mode.  (GNU ld and
2456      Gold do not have this restriction.)  */
2457   bfd_ardata (arch)->armap_timestamp = 0;
2458   uid = 0;
2459   gid = 0;
2460   if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0)
2461     {
2462       struct stat statbuf;
2463
2464       if (stat (arch->filename, &statbuf) == 0)
2465         bfd_ardata (arch)->armap_timestamp = (statbuf.st_mtime
2466                                               + ARMAP_TIME_OFFSET);
2467       uid = getuid();
2468       gid = getgid();
2469     }
2470
2471   memset (&hdr, ' ', sizeof (struct ar_hdr));
2472   memcpy (hdr.ar_name, RANLIBMAG, strlen (RANLIBMAG));
2473   bfd_ardata (arch)->armap_datepos = (SARMAG
2474                                       + offsetof (struct ar_hdr, ar_date[0]));
2475   _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2476                     bfd_ardata (arch)->armap_timestamp);
2477   _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", uid);
2478   _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", gid);
2479   if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))
2480     return FALSE;
2481   memcpy (hdr.ar_fmag, ARFMAG, 2);
2482   if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2483       != sizeof (struct ar_hdr))
2484     return FALSE;
2485   H_PUT_32 (arch, ranlibsize, temp);
2486   if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
2487     return FALSE;
2488
2489   for (count = 0; count < orl_count; count++)
2490     {
2491       unsigned int offset;
2492       bfd_byte buf[BSD_SYMDEF_SIZE];
2493
2494       if (map[count].u.abfd != last_elt)
2495         {
2496           do
2497             {
2498               struct areltdata *ared = arch_eltdata (current);
2499
2500               firstreal += (ared->parsed_size + ared->extra_size
2501                             + sizeof (struct ar_hdr));
2502               firstreal += firstreal % 2;
2503               current = current->archive_next;
2504             }
2505           while (current != map[count].u.abfd);
2506         }
2507
2508       /* The archive file format only has 4 bytes to store the offset
2509          of the member.  Check to make sure that firstreal has not grown
2510          too big.  */
2511       offset = (unsigned int) firstreal;
2512       if (firstreal != (file_ptr) offset)
2513         {
2514           bfd_set_error (bfd_error_file_truncated);
2515           return FALSE;
2516         }
2517
2518       last_elt = current;
2519       H_PUT_32 (arch, map[count].namidx, buf);
2520       H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE);
2521       if (bfd_bwrite (buf, BSD_SYMDEF_SIZE, arch)
2522           != BSD_SYMDEF_SIZE)
2523         return FALSE;
2524     }
2525
2526   /* Now write the strings themselves.  */
2527   H_PUT_32 (arch, stringsize, temp);
2528   if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
2529     return FALSE;
2530   for (count = 0; count < orl_count; count++)
2531     {
2532       size_t len = strlen (*map[count].name) + 1;
2533
2534       if (bfd_bwrite (*map[count].name, len, arch) != len)
2535         return FALSE;
2536     }
2537
2538   /* The spec sez this should be a newline.  But in order to be
2539      bug-compatible for sun's ar we use a null.  */
2540   if (padit)
2541     {
2542       if (bfd_bwrite ("", 1, arch) != 1)
2543         return FALSE;
2544     }
2545
2546   return TRUE;
2547 }
2548
2549 /* At the end of archive file handling, update the timestamp in the
2550    file, so the linker will accept it.
2551
2552    Return TRUE if the timestamp was OK, or an unusual problem happened.
2553    Return FALSE if we updated the timestamp.  */
2554
2555 bfd_boolean
2556 _bfd_archive_bsd_update_armap_timestamp (bfd *arch)
2557 {
2558   struct stat archstat;
2559   struct ar_hdr hdr;
2560
2561   /* If creating deterministic archives, just leave the timestamp as-is.  */
2562   if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) != 0)
2563     return TRUE;
2564
2565   /* Flush writes, get last-write timestamp from file, and compare it
2566      to the timestamp IN the file.  */
2567   bfd_flush (arch);
2568   if (bfd_stat (arch, &archstat) == -1)
2569     {
2570       bfd_perror (_("Reading archive file mod timestamp"));
2571
2572       /* Can't read mod time for some reason.  */
2573       return TRUE;
2574     }
2575   if (((long) archstat.st_mtime) <= bfd_ardata (arch)->armap_timestamp)
2576     /* OK by the linker's rules.  */
2577     return TRUE;
2578
2579   /* Update the timestamp.  */
2580   bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET;
2581
2582   /* Prepare an ASCII version suitable for writing.  */
2583   memset (hdr.ar_date, ' ', sizeof (hdr.ar_date));
2584   _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2585                     bfd_ardata (arch)->armap_timestamp);
2586
2587   /* Write it into the file.  */
2588   bfd_ardata (arch)->armap_datepos = (SARMAG
2589                                       + offsetof (struct ar_hdr, ar_date[0]));
2590   if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0
2591       || (bfd_bwrite (hdr.ar_date, sizeof (hdr.ar_date), arch)
2592           != sizeof (hdr.ar_date)))
2593     {
2594       bfd_perror (_("Writing updated armap timestamp"));
2595
2596       /* Some error while writing.  */
2597       return TRUE;
2598     }
2599
2600   /* We updated the timestamp successfully.  */
2601   return FALSE;
2602 }
2603 \f
2604 /* A coff armap looks like :
2605    lARMAG
2606    struct ar_hdr with name = '/'
2607    number of symbols
2608    offset of file for symbol 0
2609    offset of file for symbol 1
2610
2611    offset of file for symbol n-1
2612    symbol name 0
2613    symbol name 1
2614
2615    symbol name n-1  */
2616
2617 bfd_boolean
2618 coff_write_armap (bfd *arch,
2619                   unsigned int elength,
2620                   struct orl *map,
2621                   unsigned int symbol_count,
2622                   int stridx)
2623 {
2624   /* The size of the ranlib is the number of exported symbols in the
2625      archive * the number of bytes in an int, + an int for the count.  */
2626   unsigned int ranlibsize = (symbol_count * 4) + 4;
2627   unsigned int stringsize = stridx;
2628   unsigned int mapsize = stringsize + ranlibsize;
2629   file_ptr archive_member_file_ptr;
2630   bfd *current = arch->archive_head;
2631   unsigned int count;
2632   struct ar_hdr hdr;
2633   int padit = mapsize & 1;
2634
2635   if (padit)
2636     mapsize++;
2637
2638   /* Work out where the first object file will go in the archive.  */
2639   archive_member_file_ptr = (mapsize
2640                              + elength
2641                              + sizeof (struct ar_hdr)
2642                              + SARMAG);
2643
2644   memset (&hdr, ' ', sizeof (struct ar_hdr));
2645   hdr.ar_name[0] = '/';
2646   if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))
2647     return FALSE;
2648   _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2649                     ((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0
2650                      ? time (NULL) : 0));
2651   /* This, at least, is what Intel coff sets the values to.  */
2652   _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", 0);
2653   _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", 0);
2654   _bfd_ar_spacepad (hdr.ar_mode, sizeof (hdr.ar_mode), "%-7lo", 0);
2655   memcpy (hdr.ar_fmag, ARFMAG, 2);
2656
2657   /* Write the ar header for this item and the number of symbols.  */
2658   if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2659       != sizeof (struct ar_hdr))
2660     return FALSE;
2661
2662   if (!bfd_write_bigendian_4byte_int (arch, symbol_count))
2663     return FALSE;
2664
2665   /* Two passes, first write the file offsets for each symbol -
2666      remembering that each offset is on a two byte boundary.  */
2667
2668   /* Write out the file offset for the file associated with each
2669      symbol, and remember to keep the offsets padded out.  */
2670
2671   current = arch->archive_head;
2672   count = 0;
2673   while (current != NULL && count < symbol_count)
2674     {
2675       /* For each symbol which is used defined in this object, write
2676          out the object file's address in the archive.  */
2677
2678       while (count < symbol_count && map[count].u.abfd == current)
2679         {
2680           unsigned int offset = (unsigned int) archive_member_file_ptr;
2681
2682           /* Catch an attempt to grow an archive past its 4Gb limit.  */
2683           if (archive_member_file_ptr != (file_ptr) offset)
2684             {
2685               bfd_set_error (bfd_error_file_truncated);
2686               return FALSE;
2687             }
2688           if (!bfd_write_bigendian_4byte_int (arch, offset))
2689             return FALSE;
2690           count++;
2691         }
2692       archive_member_file_ptr += sizeof (struct ar_hdr);
2693       if (! bfd_is_thin_archive (arch))
2694         {
2695           /* Add size of this archive entry.  */
2696           archive_member_file_ptr += arelt_size (current);
2697           /* Remember about the even alignment.  */
2698           archive_member_file_ptr += archive_member_file_ptr % 2;
2699         }
2700       current = current->archive_next;
2701     }
2702
2703   /* Now write the strings themselves.  */
2704   for (count = 0; count < symbol_count; count++)
2705     {
2706       size_t len = strlen (*map[count].name) + 1;
2707
2708       if (bfd_bwrite (*map[count].name, len, arch) != len)
2709         return FALSE;
2710     }
2711
2712   /* The spec sez this should be a newline.  But in order to be
2713      bug-compatible for arc960 we use a null.  */
2714   if (padit)
2715     {
2716       if (bfd_bwrite ("", 1, arch) != 1)
2717         return FALSE;
2718     }
2719
2720   return TRUE;
2721 }
2722
2723 static int
2724 archive_close_worker (void **slot, void *inf ATTRIBUTE_UNUSED)
2725 {
2726   struct ar_cache *ent = (struct ar_cache *) *slot;
2727
2728   bfd_close_all_done (ent->arbfd);
2729   return 1;
2730 }
2731
2732 bfd_boolean
2733 _bfd_archive_close_and_cleanup (bfd *abfd)
2734 {
2735   if (bfd_read_p (abfd) && abfd->format == bfd_archive)
2736     {
2737       bfd *nbfd;
2738       bfd *next;
2739       htab_t htab;
2740
2741       /* Close nested archives (if this bfd is a thin archive).  */
2742       for (nbfd = abfd->nested_archives; nbfd; nbfd = next)
2743         {
2744           next = nbfd->archive_next;
2745           bfd_close (nbfd);
2746         }
2747
2748       htab = bfd_ardata (abfd)->cache;
2749       if (htab)
2750         {
2751           htab_traverse_noresize (htab, archive_close_worker, NULL);
2752           htab_delete (htab);
2753           bfd_ardata (abfd)->cache = NULL;
2754         }
2755     }
2756   if (arch_eltdata (abfd) != NULL)
2757     {
2758       struct areltdata *ared = arch_eltdata (abfd);
2759       htab_t htab = (htab_t) ared->parent_cache;
2760
2761       if (htab)
2762         {
2763           struct ar_cache ent;
2764           void **slot;
2765
2766           ent.ptr = ared->key;
2767           slot = htab_find_slot (htab, &ent, NO_INSERT);
2768           if (slot != NULL)
2769             {
2770               BFD_ASSERT (((struct ar_cache *) *slot)->arbfd == abfd);
2771               htab_clear_slot (htab, slot);
2772             }
2773         }
2774     }
2775   if (abfd->is_linker_output)
2776     (*abfd->link.hash->hash_table_free) (abfd);
2777
2778   return TRUE;
2779 }