bfd/archive.c

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