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