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