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