1 /* BFD back-end for archive files (libraries).
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
4 2012 Free Software Foundation, Inc.
5 Written by Cygnus Support. Mostly Gumby Henkel-Wallace's fault.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
24 @setfilename archive-info
29 An archive (or library) is just another BFD. It has a symbol
30 table, although there's not much a user program will do with it.
32 The big difference between an archive BFD and an ordinary BFD
33 is that the archive doesn't have sections. Instead it has a
34 chain of BFDs that are considered its contents. These BFDs can
35 be manipulated like any other. The BFDs contained in an
36 archive opened for reading will all be opened for reading. You
37 may put either input or output BFDs into an archive opened for
38 output; they will be handled correctly when the archive is closed.
40 Use <<bfd_openr_next_archived_file>> to step through
41 the contents of an archive opened for input. You don't
42 have to read the entire archive if you don't want
43 to! Read it until you find what you want.
45 A BFD returned by <<bfd_openr_next_archived_file>> can be
46 closed manually with <<bfd_close>>. If you do not close it,
47 then a second iteration through the members of an archive may
48 return the same BFD. If you close the archive BFD, then all
49 the member BFDs will automatically be closed as well.
51 Archive contents of output BFDs are chained through the
52 <<archive_next>> pointer in a BFD. The first one is findable
53 through the <<archive_head>> slot of the archive. Set it with
54 <<bfd_set_archive_head>> (q.v.). A given BFD may be in only
55 one open output archive at a time.
57 As expected, the BFD archive code is more general than the
58 archive code of any given environment. BFD archives may
59 contain files of different formats (e.g., a.out and coff) and
60 even different architectures. You may even place archives
61 recursively into archives!
63 This can cause unexpected confusion, since some archive
64 formats are more expressive than others. For instance, Intel
65 COFF archives can preserve long filenames; SunOS a.out archives
66 cannot. If you move a file from the first to the second
67 format and back again, the filename may be truncated.
68 Likewise, different a.out environments have different
69 conventions as to how they truncate filenames, whether they
70 preserve directory names in filenames, etc. When
71 interoperating with native tools, be sure your files are
74 Beware: most of these formats do not react well to the
75 presence of spaces in filenames. We do the best we can, but
76 can't always handle this case due to restrictions in the format of
77 archives. Many Unix utilities are braindead in regards to
78 spaces and such in filenames anyway, so this shouldn't be much
81 Archives are supported in BFD in <<archive.c>>.
88 o - all archive elements start on an even boundary, newline padded;
89 o - all arch headers are char *;
90 o - all arch headers are the same size (across architectures).
93 /* Some formats provide a way to cram a long filename into the short
94 (16 chars) space provided by a BSD archive. The trick is: make a
95 special "file" in the front of the archive, sort of like the SYMDEF
96 entry. If the filename is too long to fit, put it in the extended
97 name table, and use its index as the filename. To prevent
98 confusion prepend the index with a space. This means you can't
99 have filenames that start with a space, but then again, many Unix
100 utilities can't handle that anyway.
102 This scheme unfortunately requires that you stand on your head in
103 order to write an archive since you need to put a magic file at the
104 front, and need to touch every entry to do so. C'est la vie.
106 We support two variants of this idea:
107 The SVR4 format (extended name table is named "//"),
108 and an extended pseudo-BSD variant (extended name table is named
109 "ARFILENAMES/"). The origin of the latter format is uncertain.
111 BSD 4.4 uses a third scheme: It writes a long filename
112 directly after the header. This allows 'ar q' to work.
115 /* Summary of archive member names:
117 Symbol table (must be first):
118 "__.SYMDEF " - Symbol table, Berkeley style, produced by ranlib.
119 "/ " - Symbol table, system 5 style.
121 Long name table (must be before regular file members):
122 "// " - Long name table, System 5 R4 style.
123 "ARFILENAMES/ " - Long name table, non-standard extended BSD (not BSD 4.4).
125 Regular file members with short names:
126 "filename.o/ " - Regular file, System 5 style (embedded spaces ok).
127 "filename.o " - Regular file, Berkeley style (no embedded spaces).
129 Regular files with long names (or embedded spaces, for BSD variants):
130 "/18 " - SVR4 style, name at offset 18 in name table.
131 "#1/23 " - Long name (or embedded spaces) 23 characters long,
132 BSD 4.4 style, full name follows header.
133 " 18 " - Long name 18 characters long, extended pseudo-BSD.
138 #include "libiberty.h"
141 #include "aout/ranlib.h"
142 #include "safe-ctype.h"
144 #include "filenames.h"
150 /* We keep a cache of archive filepointers to archive elements to
151 speed up searching the archive by filepos. We only add an entry to
152 the cache when we actually read one. We also don't sort the cache;
153 it's generally short enough to search linearly.
154 Note that the pointers here point to the front of the ar_hdr, not
155 to the front of the contents! */
162 #define ar_padchar(abfd) ((abfd)->xvec->ar_pad_char)
163 #define ar_maxnamelen(abfd) ((abfd)->xvec->ar_max_namelen)
165 #define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data))
166 #define arch_hdr(bfd) ((struct ar_hdr *) arch_eltdata (bfd)->arch_header)
168 /* True iff NAME designated a BSD 4.4 extended name. */
170 #define is_bsd44_extended_name(NAME) \
171 (NAME[0] == '#' && NAME[1] == '1' && NAME[2] == '/' && ISDIGIT (NAME[3]))
174 _bfd_ar_spacepad (char *p, size_t n, const char *fmt, long val)
179 snprintf (buf, sizeof (buf), fmt, val);
183 memcpy (p, buf, len);
184 memset (p + len, ' ', n - len);
191 _bfd_ar_sizepad (char *p, size_t n, bfd_size_type size)
196 snprintf (buf, sizeof (buf), "%-10" BFD_VMA_FMT "u", size);
200 bfd_set_error (bfd_error_file_too_big);
205 memcpy (p, buf, len);
206 memset (p + len, ' ', n - len);
214 _bfd_generic_mkarchive (bfd *abfd)
216 bfd_size_type amt = sizeof (struct artdata);
218 abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc (abfd, amt);
219 if (bfd_ardata (abfd) == NULL)
222 /* Already cleared by bfd_zalloc above.
223 bfd_ardata (abfd)->cache = NULL;
224 bfd_ardata (abfd)->archive_head = NULL;
225 bfd_ardata (abfd)->symdefs = NULL;
226 bfd_ardata (abfd)->extended_names = NULL;
227 bfd_ardata (abfd)->extended_names_size = 0;
228 bfd_ardata (abfd)->tdata = NULL; */
238 symindex bfd_get_next_mapent
239 (bfd *abfd, symindex previous, carsym **sym);
242 Step through archive @var{abfd}'s symbol table (if it
243 has one). Successively update @var{sym} with the next symbol's
244 information, returning that symbol's (internal) index into the
247 Supply <<BFD_NO_MORE_SYMBOLS>> as the @var{previous} entry to get
248 the first one; returns <<BFD_NO_MORE_SYMBOLS>> when you've already
251 A <<carsym>> is a canonical archive symbol. The only
252 user-visible element is its name, a null-terminated string.
256 bfd_get_next_mapent (bfd *abfd, symindex prev, carsym **entry)
258 if (!bfd_has_map (abfd))
260 bfd_set_error (bfd_error_invalid_operation);
261 return BFD_NO_MORE_SYMBOLS;
264 if (prev == BFD_NO_MORE_SYMBOLS)
268 if (prev >= bfd_ardata (abfd)->symdef_count)
269 return BFD_NO_MORE_SYMBOLS;
271 *entry = (bfd_ardata (abfd)->symdefs + prev);
275 /* To be called by backends only. */
278 _bfd_create_empty_archive_element_shell (bfd *obfd)
280 return _bfd_new_bfd_contained_in (obfd);
288 bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);
291 Set the head of the chain of
292 BFDs contained in the archive @var{output} to @var{new_head}.
296 bfd_set_archive_head (bfd *output_archive, bfd *new_head)
298 output_archive->archive_head = new_head;
303 _bfd_look_for_bfd_in_cache (bfd *arch_bfd, file_ptr filepos)
305 htab_t hash_table = bfd_ardata (arch_bfd)->cache;
312 struct ar_cache *entry = (struct ar_cache *) htab_find (hash_table, &m);
323 hash_file_ptr (const void * p)
325 return (hashval_t) (((struct ar_cache *) p)->ptr);
328 /* Returns non-zero if P1 and P2 are equal. */
331 eq_file_ptr (const void * p1, const void * p2)
333 struct ar_cache *arc1 = (struct ar_cache *) p1;
334 struct ar_cache *arc2 = (struct ar_cache *) p2;
335 return arc1->ptr == arc2->ptr;
338 /* The calloc function doesn't always take size_t (e.g. on VMS)
339 so wrap it to avoid a compile time warning. */
342 _bfd_calloc_wrapper (size_t a, size_t b)
344 return calloc (a, b);
347 /* Kind of stupid to call cons for each one, but we don't do too many. */
350 _bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt)
352 struct ar_cache *cache;
353 htab_t hash_table = bfd_ardata (arch_bfd)->cache;
355 /* If the hash table hasn't been created, create it. */
356 if (hash_table == NULL)
358 hash_table = htab_create_alloc (16, hash_file_ptr, eq_file_ptr,
359 NULL, _bfd_calloc_wrapper, free);
360 if (hash_table == NULL)
362 bfd_ardata (arch_bfd)->cache = hash_table;
365 /* Insert new_elt into the hash table by filepos. */
366 cache = (struct ar_cache *) bfd_zalloc (arch_bfd, sizeof (struct ar_cache));
367 cache->ptr = filepos;
368 cache->arbfd = new_elt;
369 *htab_find_slot (hash_table, (const void *) cache, INSERT) = cache;
371 /* Provide a means of accessing this from child. */
372 arch_eltdata (new_elt)->parent_cache = hash_table;
373 arch_eltdata (new_elt)->key = filepos;
379 _bfd_find_nested_archive (bfd *arch_bfd, const char *filename)
384 for (abfd = arch_bfd->nested_archives;
386 abfd = abfd->archive_next)
388 if (filename_cmp (filename, abfd->filename) == 0)
392 if (!arch_bfd->target_defaulted)
393 target = arch_bfd->xvec->name;
394 abfd = bfd_openr (filename, target);
397 abfd->archive_next = arch_bfd->nested_archives;
398 arch_bfd->nested_archives = abfd;
403 /* The name begins with space. Hence the rest of the name is an index into
407 get_extended_arelt_filename (bfd *arch, const char *name, file_ptr *originp)
409 unsigned long table_index = 0;
412 /* Should extract string so that I can guarantee not to overflow into
413 the next region, but I'm too lazy. */
415 /* Skip first char, which is '/' in SVR4 or ' ' in some other variants. */
416 table_index = strtol (name + 1, (char **) &endp, 10);
417 if (errno != 0 || table_index >= bfd_ardata (arch)->extended_names_size)
419 bfd_set_error (bfd_error_malformed_archive);
422 /* In a thin archive, a member of an archive-within-an-archive
423 will have the offset in the inner archive encoded here. */
424 if (bfd_is_thin_archive (arch) && endp != NULL && *endp == ':')
426 file_ptr origin = strtol (endp + 1, NULL, 10);
430 bfd_set_error (bfd_error_malformed_archive);
438 return bfd_ardata (arch)->extended_names + table_index;
441 /* This functions reads an arch header and returns an areltdata pointer, or
444 Presumes the file pointer is already in the right place (ie pointing
445 to the ar_hdr in the file). Moves the file pointer; on success it
446 should be pointing to the front of the file contents; on failure it
447 could have been moved arbitrarily. */
450 _bfd_generic_read_ar_hdr (bfd *abfd)
452 return _bfd_generic_read_ar_hdr_mag (abfd, NULL);
455 /* Alpha ECOFF uses an optional different ARFMAG value, so we have a
456 variant of _bfd_generic_read_ar_hdr which accepts a magic string. */
459 _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
462 char *hdrp = (char *) &hdr;
463 bfd_size_type parsed_size;
464 struct areltdata *ared;
465 char *filename = NULL;
466 bfd_size_type namelen = 0;
467 bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
470 unsigned int extra_size = 0;
474 if (bfd_bread (hdrp, sizeof (struct ar_hdr), abfd) != sizeof (struct ar_hdr))
476 if (bfd_get_error () != bfd_error_system_call)
477 bfd_set_error (bfd_error_no_more_archived_files);
480 if (strncmp (hdr.ar_fmag, ARFMAG, 2) != 0
482 || strncmp (hdr.ar_fmag, mag, 2) != 0))
484 bfd_set_error (bfd_error_malformed_archive);
489 fmag_save = hdr.ar_fmag[0];
491 scan = sscanf (hdr.ar_size, "%" BFD_VMA_FMT "u", &parsed_size);
492 hdr.ar_fmag[0] = fmag_save;
495 bfd_set_error (bfd_error_malformed_archive);
499 /* Extract the filename from the archive - there are two ways to
500 specify an extended name table, either the first char of the
501 name is a space, or it's a slash. */
502 if ((hdr.ar_name[0] == '/'
503 || (hdr.ar_name[0] == ' '
504 && memchr (hdr.ar_name, '/', ar_maxnamelen (abfd)) == NULL))
505 && bfd_ardata (abfd)->extended_names != NULL)
507 filename = get_extended_arelt_filename (abfd, hdr.ar_name, &origin);
508 if (filename == NULL)
511 /* BSD4.4-style long filename. */
512 else if (is_bsd44_extended_name (hdr.ar_name))
514 /* BSD-4.4 extended name */
515 namelen = atoi (&hdr.ar_name[3]);
516 allocsize += namelen + 1;
517 parsed_size -= namelen;
518 extra_size = namelen;
520 allocptr = (char *) bfd_zmalloc (allocsize);
521 if (allocptr == NULL)
524 + sizeof (struct areltdata)
525 + sizeof (struct ar_hdr));
526 if (bfd_bread (filename, namelen, abfd) != namelen)
529 if (bfd_get_error () != bfd_error_system_call)
530 bfd_set_error (bfd_error_no_more_archived_files);
533 filename[namelen] = '\0';
537 /* We judge the end of the name by looking for '/' or ' '.
538 Note: The SYSV format (terminated by '/') allows embedded
539 spaces, so only look for ' ' if we don't find '/'. */
542 e = (char *) memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
545 e = (char *) memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
547 e = (char *) memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
551 namelen = e - hdr.ar_name;
554 /* If we didn't find a termination character, then the name
555 must be the entire field. */
556 namelen = ar_maxnamelen (abfd);
559 allocsize += namelen + 1;
564 allocptr = (char *) bfd_zmalloc (allocsize);
565 if (allocptr == NULL)
569 ared = (struct areltdata *) allocptr;
571 ared->arch_header = allocptr + sizeof (struct areltdata);
572 memcpy (ared->arch_header, &hdr, sizeof (struct ar_hdr));
573 ared->parsed_size = parsed_size;
574 ared->extra_size = extra_size;
575 ared->origin = origin;
577 if (filename != NULL)
578 ared->filename = filename;
581 ared->filename = allocptr + (sizeof (struct areltdata) +
582 sizeof (struct ar_hdr));
584 memcpy (ared->filename, hdr.ar_name, namelen);
585 ared->filename[namelen] = '\0';
591 /* Append the relative pathname for a member of the thin archive
592 to the pathname of the directory containing the archive. */
595 _bfd_append_relative_path (bfd *arch, char *elt_name)
597 const char *arch_name = arch->filename;
598 const char *base_name = lbasename (arch_name);
602 if (base_name == arch_name)
605 prefix_len = base_name - arch_name;
606 filename = (char *) bfd_alloc (arch, prefix_len + strlen (elt_name) + 1);
607 if (filename == NULL)
610 strncpy (filename, arch_name, prefix_len);
611 strcpy (filename + prefix_len, elt_name);
615 /* This is an internal function; it's mainly used when indexing
616 through the archive symbol table, but also used to get the next
617 element, since it handles the bookkeeping so nicely for us. */
620 _bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos)
622 struct areltdata *new_areldata;
626 n_nfd = _bfd_look_for_bfd_in_cache (archive, filepos);
630 if (0 > bfd_seek (archive, filepos, SEEK_SET))
633 if ((new_areldata = (struct areltdata *) _bfd_read_ar_hdr (archive)) == NULL)
636 filename = new_areldata->filename;
638 if (bfd_is_thin_archive (archive))
642 /* This is a proxy entry for an external file. */
643 if (! IS_ABSOLUTE_PATH (filename))
645 filename = _bfd_append_relative_path (archive, filename);
646 if (filename == NULL)
653 if (new_areldata->origin > 0)
655 /* This proxy entry refers to an element of a nested archive.
656 Locate the member of that archive and return a bfd for it. */
657 bfd *ext_arch = _bfd_find_nested_archive (archive, filename);
660 || ! bfd_check_format (ext_arch, bfd_archive))
665 n_nfd = _bfd_get_elt_at_filepos (ext_arch, new_areldata->origin);
671 n_nfd->proxy_origin = bfd_tell (archive);
674 /* It's not an element of a nested archive;
675 open the external file as a bfd. */
677 if (!archive->target_defaulted)
678 target = archive->xvec->name;
679 n_nfd = bfd_openr (filename, target);
681 bfd_set_error (bfd_error_malformed_archive);
685 n_nfd = _bfd_create_empty_archive_element_shell (archive);
694 n_nfd->proxy_origin = bfd_tell (archive);
696 if (bfd_is_thin_archive (archive))
702 n_nfd->origin = n_nfd->proxy_origin;
703 n_nfd->filename = filename;
706 n_nfd->arelt_data = new_areldata;
708 /* Copy BFD_COMPRESS and BFD_DECOMPRESS flags. */
709 n_nfd->flags |= archive->flags & (BFD_COMPRESS | BFD_DECOMPRESS);
711 if (_bfd_add_bfd_to_archive_cache (archive, filepos, n_nfd))
715 n_nfd->arelt_data = NULL;
719 /* Return the BFD which is referenced by the symbol in ABFD indexed by
720 SYM_INDEX. SYM_INDEX should have been returned by bfd_get_next_mapent. */
723 _bfd_generic_get_elt_at_index (bfd *abfd, symindex sym_index)
727 entry = bfd_ardata (abfd)->symdefs + sym_index;
728 return _bfd_get_elt_at_filepos (abfd, entry->file_offset);
733 bfd_openr_next_archived_file
736 bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous);
739 Provided a BFD, @var{archive}, containing an archive and NULL, open
740 an input BFD on the first contained element and returns that.
741 Subsequent calls should pass
742 the archive and the previous return value to return a created
743 BFD to the next contained element. NULL is returned when there
748 bfd_openr_next_archived_file (bfd *archive, bfd *last_file)
750 if ((bfd_get_format (archive) != bfd_archive)
751 || (archive->direction == write_direction))
753 bfd_set_error (bfd_error_invalid_operation);
757 return BFD_SEND (archive,
758 openr_next_archived_file, (archive, last_file));
762 bfd_generic_openr_next_archived_file (bfd *archive, bfd *last_file)
767 filestart = bfd_ardata (archive)->first_file_filepos;
770 bfd_size_type size = arelt_size (last_file);
772 filestart = last_file->proxy_origin;
773 if (! bfd_is_thin_archive (archive))
775 /* Pad to an even boundary...
776 Note that last_file->origin can be odd in the case of
777 BSD-4.4-style element with a long odd size. */
778 filestart += filestart % 2;
781 return _bfd_get_elt_at_filepos (archive, filestart);
785 bfd_generic_archive_p (bfd *abfd)
787 struct artdata *tdata_hold;
788 char armag[SARMAG + 1];
791 if (bfd_bread (armag, SARMAG, abfd) != SARMAG)
793 if (bfd_get_error () != bfd_error_system_call)
794 bfd_set_error (bfd_error_wrong_format);
798 bfd_is_thin_archive (abfd) = (strncmp (armag, ARMAGT, SARMAG) == 0);
800 if (strncmp (armag, ARMAG, SARMAG) != 0
801 && strncmp (armag, ARMAGB, SARMAG) != 0
802 && ! bfd_is_thin_archive (abfd))
805 tdata_hold = bfd_ardata (abfd);
807 amt = sizeof (struct artdata);
808 bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
809 if (bfd_ardata (abfd) == NULL)
811 bfd_ardata (abfd) = tdata_hold;
815 bfd_ardata (abfd)->first_file_filepos = SARMAG;
816 /* Cleared by bfd_zalloc above.
817 bfd_ardata (abfd)->cache = NULL;
818 bfd_ardata (abfd)->archive_head = NULL;
819 bfd_ardata (abfd)->symdefs = NULL;
820 bfd_ardata (abfd)->extended_names = NULL;
821 bfd_ardata (abfd)->extended_names_size = 0;
822 bfd_ardata (abfd)->tdata = NULL; */
824 if (!BFD_SEND (abfd, _bfd_slurp_armap, (abfd))
825 || !BFD_SEND (abfd, _bfd_slurp_extended_name_table, (abfd)))
827 if (bfd_get_error () != bfd_error_system_call)
828 bfd_set_error (bfd_error_wrong_format);
829 bfd_release (abfd, bfd_ardata (abfd));
830 bfd_ardata (abfd) = tdata_hold;
834 if (abfd->target_defaulted && bfd_has_map (abfd))
838 /* This archive has a map, so we may presume that the contents
839 are object files. Make sure that if the first file in the
840 archive can be recognized as an object file, it is for this
841 target. If not, assume that this is the wrong format. If
842 the first file is not an object file, somebody is doing
843 something weird, and we permit it so that ar -t will work.
845 This is done because any normal format will recognize any
846 normal archive, regardless of the format of the object files.
847 We do accept an empty archive. */
849 first = bfd_openr_next_archived_file (abfd, NULL);
852 first->target_defaulted = FALSE;
853 if (bfd_check_format (first, bfd_object)
854 && first->xvec != abfd->xvec)
855 bfd_set_error (bfd_error_wrong_object_format);
856 /* And we ought to close `first' here too. */
863 /* Some constants for a 32 bit BSD archive structure. We do not
864 support 64 bit archives presently; so far as I know, none actually
865 exist. Supporting them would require changing these constants, and
866 changing some H_GET_32 to H_GET_64. */
868 /* The size of an external symdef structure. */
869 #define BSD_SYMDEF_SIZE 8
871 /* The offset from the start of a symdef structure to the file offset. */
872 #define BSD_SYMDEF_OFFSET_SIZE 4
874 /* The size of the symdef count. */
875 #define BSD_SYMDEF_COUNT_SIZE 4
877 /* The size of the string count. */
878 #define BSD_STRING_COUNT_SIZE 4
880 /* Read a BSD-style archive symbol table. Returns FALSE on error,
884 do_slurp_bsd_armap (bfd *abfd)
886 struct areltdata *mapdata;
887 unsigned int counter;
888 bfd_byte *raw_armap, *rbase;
889 struct artdata *ardata = bfd_ardata (abfd);
891 bfd_size_type parsed_size, amt;
894 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
897 parsed_size = mapdata->parsed_size;
900 raw_armap = (bfd_byte *) bfd_zalloc (abfd, parsed_size);
901 if (raw_armap == NULL)
904 if (bfd_bread (raw_armap, parsed_size, abfd) != parsed_size)
906 if (bfd_get_error () != bfd_error_system_call)
907 bfd_set_error (bfd_error_malformed_archive);
909 bfd_release (abfd, raw_armap);
913 ardata->symdef_count = H_GET_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE;
915 if (ardata->symdef_count * BSD_SYMDEF_SIZE >
916 parsed_size - BSD_SYMDEF_COUNT_SIZE)
918 /* Probably we're using the wrong byte ordering. */
919 bfd_set_error (bfd_error_wrong_format);
924 rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE;
925 stringbase = ((char *) rbase
926 + ardata->symdef_count * BSD_SYMDEF_SIZE
927 + BSD_STRING_COUNT_SIZE);
928 amt = ardata->symdef_count * sizeof (carsym);
929 ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt);
930 if (!ardata->symdefs)
933 for (counter = 0, set = ardata->symdefs;
934 counter < ardata->symdef_count;
935 counter++, set++, rbase += BSD_SYMDEF_SIZE)
937 set->name = H_GET_32 (abfd, rbase) + stringbase;
938 set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
941 ardata->first_file_filepos = bfd_tell (abfd);
942 /* Pad to an even boundary if you have to. */
943 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
944 /* FIXME, we should provide some way to free raw_ardata when
945 we are done using the strings from it. For now, it seems
946 to be allocated on an objalloc anyway... */
947 bfd_has_map (abfd) = TRUE;
951 /* Read a COFF archive symbol table. Returns FALSE on error, TRUE
955 do_slurp_coff_armap (bfd *abfd)
957 struct areltdata *mapdata;
958 int *raw_armap, *rawptr;
959 struct artdata *ardata = bfd_ardata (abfd);
961 bfd_size_type stringsize;
962 bfd_size_type parsed_size;
964 bfd_size_type nsymz; /* Number of symbols in armap. */
965 bfd_vma (*swap) (const void *);
966 char int_buf[sizeof (long)];
967 bfd_size_type carsym_size, ptrsize;
970 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
973 parsed_size = mapdata->parsed_size;
976 if (bfd_bread (int_buf, 4, abfd) != 4)
978 if (bfd_get_error () != bfd_error_system_call)
979 bfd_set_error (bfd_error_malformed_archive);
982 /* It seems that all numeric information in a coff archive is always
983 in big endian format, nomatter the host or target. */
985 nsymz = bfd_getb32 (int_buf);
986 stringsize = parsed_size - (4 * nsymz) - 4;
988 /* ... except that some archive formats are broken, and it may be our
989 fault - the i960 little endian coff sometimes has big and sometimes
990 little, because our tools changed. Here's a horrible hack to clean
993 if (stringsize > 0xfffff
994 && bfd_get_arch (abfd) == bfd_arch_i960
995 && bfd_get_flavour (abfd) == bfd_target_coff_flavour)
997 /* This looks dangerous, let's do it the other way around. */
998 nsymz = bfd_getl32 (int_buf);
999 stringsize = parsed_size - (4 * nsymz) - 4;
1003 /* The coff armap must be read sequentially. So we construct a
1004 bsd-style one in core all at once, for simplicity. */
1006 if (nsymz > ~ (bfd_size_type) 0 / sizeof (carsym))
1009 carsym_size = (nsymz * sizeof (carsym));
1010 ptrsize = (4 * nsymz);
1012 if (carsym_size + stringsize + 1 <= carsym_size)
1015 ardata->symdefs = (struct carsym *) bfd_zalloc (abfd,
1016 carsym_size + stringsize + 1);
1017 if (ardata->symdefs == NULL)
1019 carsyms = ardata->symdefs;
1020 stringbase = ((char *) ardata->symdefs) + carsym_size;
1022 /* Allocate and read in the raw offsets. */
1023 raw_armap = (int *) bfd_alloc (abfd, ptrsize);
1024 if (raw_armap == NULL)
1025 goto release_symdefs;
1026 if (bfd_bread (raw_armap, ptrsize, abfd) != ptrsize
1027 || (bfd_bread (stringbase, stringsize, abfd) != stringsize))
1029 if (bfd_get_error () != bfd_error_system_call)
1030 bfd_set_error (bfd_error_malformed_archive);
1031 goto release_raw_armap;
1034 /* OK, build the carsyms. */
1035 for (i = 0; i < nsymz; i++)
1037 rawptr = raw_armap + i;
1038 carsyms->file_offset = swap ((bfd_byte *) rawptr);
1039 carsyms->name = stringbase;
1040 stringbase += strlen (stringbase) + 1;
1045 ardata->symdef_count = nsymz;
1046 ardata->first_file_filepos = bfd_tell (abfd);
1047 /* Pad to an even boundary if you have to. */
1048 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1050 bfd_has_map (abfd) = TRUE;
1051 bfd_release (abfd, raw_armap);
1053 /* Check for a second archive header (as used by PE). */
1055 struct areltdata *tmp;
1057 bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET);
1058 tmp = (struct areltdata *) _bfd_read_ar_hdr (abfd);
1061 if (tmp->arch_header[0] == '/'
1062 && tmp->arch_header[1] == ' ')
1064 ardata->first_file_filepos +=
1065 (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1;
1074 bfd_release (abfd, raw_armap);
1076 bfd_release (abfd, (ardata)->symdefs);
1080 /* This routine can handle either coff-style or bsd-style armaps
1081 (archive symbol table). Returns FALSE on error, TRUE otherwise */
1084 bfd_slurp_armap (bfd *abfd)
1087 int i = bfd_bread (nextname, 16, abfd);
1094 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1097 if (CONST_STRNEQ (nextname, "__.SYMDEF ")
1098 || CONST_STRNEQ (nextname, "__.SYMDEF/ ")) /* Old Linux archives. */
1099 return do_slurp_bsd_armap (abfd);
1100 else if (CONST_STRNEQ (nextname, "/ "))
1101 return do_slurp_coff_armap (abfd);
1102 else if (CONST_STRNEQ (nextname, "/SYM64/ "))
1104 /* 64bit ELF (Irix 6) archive. */
1106 extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *);
1107 return bfd_elf64_archive_slurp_armap (abfd);
1109 bfd_set_error (bfd_error_wrong_format);
1113 else if (CONST_STRNEQ (nextname, "#1/20 "))
1115 /* Mach-O has a special name for armap when the map is sorted by name.
1116 However because this name has a space it is slightly more difficult
1121 if (bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
1123 /* Read the extended name. We know its length. */
1124 if (bfd_bread (extname, 20, abfd) != 20)
1126 if (bfd_seek (abfd, -(file_ptr) (sizeof (hdr) + 20), SEEK_CUR) != 0)
1128 if (CONST_STRNEQ (extname, "__.SYMDEF SORTED")
1129 || CONST_STRNEQ (extname, "__.SYMDEF"))
1130 return do_slurp_bsd_armap (abfd);
1133 bfd_has_map (abfd) = FALSE;
1137 /* Returns FALSE on error, TRUE otherwise. */
1138 /* Flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
1139 header is in a slightly different order and the map name is '/'.
1140 This flavour is used by hp300hpux. */
1142 #define HPUX_SYMDEF_COUNT_SIZE 2
1145 bfd_slurp_bsd_armap_f2 (bfd *abfd)
1147 struct areltdata *mapdata;
1149 unsigned int counter;
1150 bfd_byte *raw_armap, *rbase;
1151 struct artdata *ardata = bfd_ardata (abfd);
1153 unsigned int stringsize;
1157 int i = bfd_bread (nextname, 16, abfd);
1164 /* The archive has at least 16 bytes in it. */
1165 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1168 if (CONST_STRNEQ (nextname, "__.SYMDEF ")
1169 || CONST_STRNEQ (nextname, "__.SYMDEF/ ")) /* Old Linux archives. */
1170 return do_slurp_bsd_armap (abfd);
1172 if (! CONST_STRNEQ (nextname, "/ "))
1174 bfd_has_map (abfd) = FALSE;
1178 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
1179 if (mapdata == NULL)
1182 if (mapdata->parsed_size < HPUX_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE)
1186 bfd_set_error (bfd_error_wrong_format);
1190 left = mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE - BSD_STRING_COUNT_SIZE;
1192 amt = mapdata->parsed_size;
1195 raw_armap = (bfd_byte *) bfd_zalloc (abfd, amt);
1196 if (raw_armap == NULL)
1199 if (bfd_bread (raw_armap, amt, abfd) != amt)
1201 if (bfd_get_error () != bfd_error_system_call)
1202 bfd_set_error (bfd_error_malformed_archive);
1206 ardata->symdef_count = H_GET_16 (abfd, raw_armap);
1210 stringsize = H_GET_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE);
1211 if (stringsize > left)
1215 /* Skip sym count and string sz. */
1216 stringbase = ((char *) raw_armap
1217 + HPUX_SYMDEF_COUNT_SIZE
1218 + BSD_STRING_COUNT_SIZE);
1219 rbase = (bfd_byte *) stringbase + stringsize;
1220 amt = ardata->symdef_count * BSD_SYMDEF_SIZE;
1224 ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt);
1225 if (!ardata->symdefs)
1228 for (counter = 0, set = ardata->symdefs;
1229 counter < ardata->symdef_count;
1230 counter++, set++, rbase += BSD_SYMDEF_SIZE)
1232 set->name = H_GET_32 (abfd, rbase) + stringbase;
1233 set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
1236 ardata->first_file_filepos = bfd_tell (abfd);
1237 /* Pad to an even boundary if you have to. */
1238 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1239 /* FIXME, we should provide some way to free raw_ardata when
1240 we are done using the strings from it. For now, it seems
1241 to be allocated on an objalloc anyway... */
1242 bfd_has_map (abfd) = TRUE;
1246 /** Extended name table.
1248 Normally archives support only 14-character filenames.
1250 Intel has extended the format: longer names are stored in a special
1251 element (the first in the archive, or second if there is an armap);
1252 the name in the ar_hdr is replaced by <space><index into filename
1253 element>. Index is the P.R. of an int (decimal). Data General have
1254 extended the format by using the prefix // for the special element. */
1256 /* Returns FALSE on error, TRUE otherwise. */
1259 _bfd_slurp_extended_name_table (bfd *abfd)
1262 struct areltdata *namedata;
1265 /* FIXME: Formatting sucks here, and in case of failure of BFD_READ,
1266 we probably don't want to return TRUE. */
1267 if (bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET) != 0)
1270 if (bfd_bread (nextname, 16, abfd) == 16)
1272 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1275 if (! CONST_STRNEQ (nextname, "ARFILENAMES/ ")
1276 && ! CONST_STRNEQ (nextname, "// "))
1278 bfd_ardata (abfd)->extended_names = NULL;
1279 bfd_ardata (abfd)->extended_names_size = 0;
1283 namedata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
1284 if (namedata == NULL)
1287 amt = namedata->parsed_size;
1291 bfd_ardata (abfd)->extended_names_size = amt;
1292 bfd_ardata (abfd)->extended_names = (char *) bfd_zalloc (abfd, amt + 1);
1293 if (bfd_ardata (abfd)->extended_names == NULL)
1300 if (bfd_bread (bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
1302 if (bfd_get_error () != bfd_error_system_call)
1303 bfd_set_error (bfd_error_malformed_archive);
1304 bfd_release (abfd, (bfd_ardata (abfd)->extended_names));
1305 bfd_ardata (abfd)->extended_names = NULL;
1309 /* Since the archive is supposed to be printable if it contains
1310 text, the entries in the list are newline-padded, not null
1311 padded. In SVR4-style archives, the names also have a
1312 trailing '/'. DOS/NT created archive often have \ in them
1313 We'll fix all problems here.. */
1315 char *ext_names = bfd_ardata (abfd)->extended_names;
1316 char *temp = ext_names;
1317 char *limit = temp + namedata->parsed_size;
1318 for (; temp < limit; ++temp)
1320 if (*temp == ARFMAG[1])
1321 temp[temp > ext_names && temp[-1] == '/' ? -1 : 0] = '\0';
1328 /* Pad to an even boundary if you have to. */
1329 bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd);
1330 bfd_ardata (abfd)->first_file_filepos +=
1331 (bfd_ardata (abfd)->first_file_filepos) % 2;
1340 /* Return a copy of the stuff in the filename between any :]> and a
1344 normalize (bfd *abfd, const char *file)
1350 first = file + strlen (file) - 1;
1353 while (first != file)
1357 if (*first == ':' || *first == ']' || *first == '>')
1365 copy = bfd_alloc (abfd, last - first + 1);
1369 memcpy (copy, first, last - first);
1370 copy[last - first] = 0;
1377 normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file)
1379 return lbasename (file);
1383 /* Adjust a relative path name based on the reference path.
1386 Relative path Reference path Result
1387 ------------- -------------- ------
1389 foo/bar.o lib.a foo/bar.o
1390 bar.o foo/lib.a ../bar.o
1391 foo/bar.o baz/lib.a ../foo/bar.o
1392 bar.o ../lib.a <parent of current dir>/bar.o
1393 ; ../bar.o ../lib.a bar.o
1394 ; ../bar.o lib.a ../bar.o
1395 foo/bar.o ../lib.a <parent of current dir>/foo/bar.o
1396 bar.o ../../lib.a <grandparent>/<parent>/bar.o
1397 bar.o foo/baz/lib.a ../../bar.o
1399 Note - the semicolons above are there to prevent the BFD chew
1400 utility from interpreting those lines as prototypes to put into
1401 the autogenerated bfd.h header...
1403 Note - the string is returned in a static buffer. */
1406 adjust_relative_path (const char * path, const char * ref_path)
1408 static char *pathbuf = NULL;
1409 static unsigned int pathbuf_len = 0;
1415 unsigned int dir_up = 0;
1416 unsigned int dir_down = 0;
1418 char * pwd = getpwd ();
1421 /* Remove symlinks, '.' and '..' from the paths, if possible. */
1422 lpath = lrealpath (path);
1423 pathp = lpath == NULL ? path : lpath;
1425 rpath = lrealpath (ref_path);
1426 refp = rpath == NULL ? ref_path : rpath;
1428 /* Remove common leading path elements. */
1431 const char *e1 = pathp;
1432 const char *e2 = refp;
1434 while (*e1 && ! IS_DIR_SEPARATOR (*e1))
1436 while (*e2 && ! IS_DIR_SEPARATOR (*e2))
1438 if (*e1 == '\0' || *e2 == '\0' || e1 - pathp != e2 - refp
1439 || filename_ncmp (pathp, refp, e1 - pathp) != 0)
1445 len = strlen (pathp) + 1;
1446 /* For each leading path element in the reference path,
1447 insert "../" into the path. */
1448 for (; *refp; ++refp)
1449 if (IS_DIR_SEPARATOR (*refp))
1451 /* PR 12710: If the path element is "../" then instead of
1452 inserting "../" we need to insert the name of the directory
1453 at the current level. */
1454 if (refp > ref_path + 1
1462 /* If the lrealpath calls above succeeded then we should never
1463 see dir_up and dir_down both being non-zero. */
1469 down = pwd + strlen (pwd) - 1;
1471 while (dir_down && down > pwd)
1473 if (IS_DIR_SEPARATOR (*down))
1476 BFD_ASSERT (dir_down == 0);
1477 len += strlen (down) + 1;
1482 if (len > pathbuf_len)
1484 if (pathbuf != NULL)
1487 pathbuf = (char *) bfd_malloc (len);
1488 if (pathbuf == NULL)
1494 while (dir_up-- > 0)
1496 /* FIXME: Support Windows style path separators as well. */
1497 strcpy (newp, "../");
1502 sprintf (newp, "%s/%s", down, pathp);
1504 strcpy (newp, pathp);
1512 /* Build a BFD style extended name table. */
1515 _bfd_archive_bsd_construct_extended_name_table (bfd *abfd,
1517 bfd_size_type *tablen,
1520 *name = "ARFILENAMES/";
1521 return _bfd_construct_extended_name_table (abfd, FALSE, tabloc, tablen);
1524 /* Build an SVR4 style extended name table. */
1527 _bfd_archive_coff_construct_extended_name_table (bfd *abfd,
1529 bfd_size_type *tablen,
1533 return _bfd_construct_extended_name_table (abfd, TRUE, tabloc, tablen);
1536 /* Follows archive_head and produces an extended name table if
1537 necessary. Returns (in tabloc) a pointer to an extended name
1538 table, and in tablen the length of the table. If it makes an entry
1539 it clobbers the filename so that the element may be written without
1540 further massage. Returns TRUE if it ran successfully, FALSE if
1541 something went wrong. A successful return may still involve a
1542 zero-length tablen! */
1545 _bfd_construct_extended_name_table (bfd *abfd,
1546 bfd_boolean trailing_slash,
1548 bfd_size_type *tablen)
1550 unsigned int maxname = ar_maxnamelen (abfd);
1551 bfd_size_type total_namelen = 0;
1554 const char *last_filename;
1558 last_filename = NULL;
1560 /* Figure out how long the table should be. */
1561 for (current = abfd->archive_head;
1563 current = current->archive_next)
1566 unsigned int thislen;
1568 if (bfd_is_thin_archive (abfd))
1570 const char *filename = current->filename;
1572 /* If the element being added is a member of another archive
1573 (i.e., we are flattening), use the containing archive's name. */
1574 if (current->my_archive
1575 && ! bfd_is_thin_archive (current->my_archive))
1576 filename = current->my_archive->filename;
1578 /* If the path is the same as the previous path seen,
1579 reuse it. This can happen when flattening a thin
1580 archive that contains other archives. */
1581 if (last_filename && filename_cmp (last_filename, filename) == 0)
1584 last_filename = filename;
1586 /* If the path is relative, adjust it relative to
1587 the containing archive. */
1588 if (! IS_ABSOLUTE_PATH (filename)
1589 && ! IS_ABSOLUTE_PATH (abfd->filename))
1590 normal = adjust_relative_path (filename, abfd->filename);
1594 /* In a thin archive, always store the full pathname
1595 in the extended name table. */
1596 total_namelen += strlen (normal) + 1;
1598 /* Leave room for trailing slash. */
1604 normal = normalize (current, current->filename);
1608 thislen = strlen (normal);
1610 if (thislen > maxname
1611 && (bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1614 if (thislen > maxname)
1616 /* Add one to leave room for \n. */
1617 total_namelen += thislen + 1;
1620 /* Leave room for trailing slash. */
1626 struct ar_hdr *hdr = arch_hdr (current);
1627 if (filename_ncmp (normal, hdr->ar_name, thislen) != 0
1628 || (thislen < sizeof hdr->ar_name
1629 && hdr->ar_name[thislen] != ar_padchar (current)))
1631 /* Must have been using extended format even though it
1632 didn't need to. Fix it to use normal format. */
1633 memcpy (hdr->ar_name, normal, thislen);
1634 if (thislen < maxname
1635 || (thislen == maxname && thislen < sizeof hdr->ar_name))
1636 hdr->ar_name[thislen] = ar_padchar (current);
1641 if (total_namelen == 0)
1644 *tabloc = (char *) bfd_zalloc (abfd, total_namelen);
1645 if (*tabloc == NULL)
1648 *tablen = total_namelen;
1651 last_filename = NULL;
1654 for (current = abfd->archive_head;
1656 current = current->archive_next)
1659 unsigned int thislen;
1661 const char *filename = current->filename;
1663 if (bfd_is_thin_archive (abfd))
1665 /* If the element being added is a member of another archive
1666 (i.e., we are flattening), use the containing archive's name. */
1667 if (current->my_archive
1668 && ! bfd_is_thin_archive (current->my_archive))
1669 filename = current->my_archive->filename;
1670 /* If the path is the same as the previous path seen,
1671 reuse it. This can happen when flattening a thin
1672 archive that contains other archives.
1673 If the path is relative, adjust it relative to
1674 the containing archive. */
1675 if (last_filename && filename_cmp (last_filename, filename) == 0)
1676 normal = last_filename;
1677 else if (! IS_ABSOLUTE_PATH (filename)
1678 && ! IS_ABSOLUTE_PATH (abfd->filename))
1679 normal = adjust_relative_path (filename, abfd->filename);
1685 normal = normalize (current, filename);
1690 thislen = strlen (normal);
1691 if (thislen > maxname || bfd_is_thin_archive (abfd))
1693 /* Works for now; may need to be re-engineered if we
1694 encounter an oddball archive format and want to
1695 generalise this hack. */
1696 struct ar_hdr *hdr = arch_hdr (current);
1697 if (normal == last_filename)
1698 stroff = last_stroff;
1701 strcpy (strptr, normal);
1702 if (! trailing_slash)
1703 strptr[thislen] = ARFMAG[1];
1706 strptr[thislen] = '/';
1707 strptr[thislen + 1] = ARFMAG[1];
1709 stroff = strptr - *tabloc;
1710 last_stroff = stroff;
1712 hdr->ar_name[0] = ar_padchar (current);
1713 if (bfd_is_thin_archive (abfd) && current->origin > 0)
1715 int len = snprintf (hdr->ar_name + 1, maxname - 1, "%-ld:",
1717 _bfd_ar_spacepad (hdr->ar_name + 1 + len, maxname - 1 - len,
1719 current->origin - sizeof (struct ar_hdr));
1722 _bfd_ar_spacepad (hdr->ar_name + 1, maxname - 1, "%-ld", stroff);
1723 if (normal != last_filename)
1725 strptr += thislen + 1;
1728 last_filename = filename;
1736 /* Do not construct an extended name table but transforms name field into
1737 its extended form. */
1740 _bfd_archive_bsd44_construct_extended_name_table (bfd *abfd,
1742 bfd_size_type *tablen,
1745 unsigned int maxname = ar_maxnamelen (abfd);
1752 for (current = abfd->archive_head;
1754 current = current->archive_next)
1756 const char *normal = normalize (current, current->filename);
1763 for (len = 0; normal[len]; len++)
1764 if (normal[len] == ' ')
1767 if (len > maxname || has_space)
1769 struct ar_hdr *hdr = arch_hdr (current);
1771 len = (len + 3) & ~3;
1772 arch_eltdata (current)->extra_size = len;
1773 _bfd_ar_spacepad (hdr->ar_name, maxname, "#1/%lu", len);
1780 /* Write an archive header. */
1783 _bfd_generic_write_ar_hdr (bfd *archive, bfd *abfd)
1785 struct ar_hdr *hdr = arch_hdr (abfd);
1787 if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
1792 /* Write an archive header using BSD4.4 convention. */
1795 _bfd_bsd44_write_ar_hdr (bfd *archive, bfd *abfd)
1797 struct ar_hdr *hdr = arch_hdr (abfd);
1799 if (is_bsd44_extended_name (hdr->ar_name))
1801 /* This is a BSD 4.4 extended name. */
1802 const char *fullname = normalize (abfd, abfd->filename);
1803 unsigned int len = strlen (fullname);
1804 unsigned int padded_len = (len + 3) & ~3;
1806 BFD_ASSERT (padded_len == arch_eltdata (abfd)->extra_size);
1808 if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size),
1809 arch_eltdata (abfd)->parsed_size + padded_len))
1812 if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
1815 if (bfd_bwrite (fullname, len, archive) != len)
1820 static const char pad[3] = { 0, 0, 0 };
1822 len = 4 - (len & 3);
1823 if (bfd_bwrite (pad, len, archive) != len)
1829 if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
1835 /* A couple of functions for creating ar_hdrs. */
1837 #ifdef HPUX_LARGE_AR_IDS
1838 /* Function to encode large UID/GID values according to HP. */
1841 hpux_uid_gid_encode (char str[6], long int id)
1845 str[5] = '@' + (id & 3);
1848 for (cnt = 4; cnt >= 0; --cnt, id >>= 6)
1849 str[cnt] = ' ' + (id & 0x3f);
1851 #endif /* HPUX_LARGE_AR_IDS */
1861 /* Takes a filename, returns an arelt_data for it, or NULL if it can't
1862 make one. The filename must refer to a filename in the filesystem.
1863 The filename field of the ar_hdr will NOT be initialized. If member
1864 is set, and it's an in-memory bfd, we fake it. */
1866 static struct areltdata *
1867 bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
1870 struct areltdata *ared;
1874 if (member && (member->flags & BFD_IN_MEMORY) != 0)
1876 /* Assume we just "made" the member, and fake it. */
1877 struct bfd_in_memory *bim = (struct bfd_in_memory *) member->iostream;
1878 time (&status.st_mtime);
1879 status.st_uid = getuid ();
1880 status.st_gid = getgid ();
1881 status.st_mode = 0644;
1882 status.st_size = bim->size;
1884 else if (stat (filename, &status) != 0)
1886 bfd_set_error (bfd_error_system_call);
1890 /* If the caller requested that the BFD generate deterministic output,
1891 fake values for modification time, UID, GID, and file mode. */
1892 if ((abfd->flags & BFD_DETERMINISTIC_OUTPUT) != 0)
1894 status.st_mtime = 0;
1897 status.st_mode = 0644;
1900 amt = sizeof (struct ar_hdr) + sizeof (struct areltdata);
1901 ared = (struct areltdata *) bfd_zmalloc (amt);
1904 hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));
1906 /* ar headers are space padded, not null padded! */
1907 memset (hdr, ' ', sizeof (struct ar_hdr));
1909 _bfd_ar_spacepad (hdr->ar_date, sizeof (hdr->ar_date), "%-12ld",
1911 #ifdef HPUX_LARGE_AR_IDS
1912 /* HP has a very "special" way to handle UID/GID's with numeric values
1914 if (status.st_uid > 99999)
1915 hpux_uid_gid_encode (hdr->ar_uid, (long) status.st_uid);
1918 _bfd_ar_spacepad (hdr->ar_uid, sizeof (hdr->ar_uid), "%ld",
1920 #ifdef HPUX_LARGE_AR_IDS
1921 /* HP has a very "special" way to handle UID/GID's with numeric values
1923 if (status.st_gid > 99999)
1924 hpux_uid_gid_encode (hdr->ar_gid, (long) status.st_gid);
1927 _bfd_ar_spacepad (hdr->ar_gid, sizeof (hdr->ar_gid), "%ld",
1929 _bfd_ar_spacepad (hdr->ar_mode, sizeof (hdr->ar_mode), "%-8lo",
1931 if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size), status.st_size))
1936 memcpy (hdr->ar_fmag, ARFMAG, 2);
1937 ared->parsed_size = status.st_size;
1938 ared->arch_header = (char *) hdr;
1943 /* Analogous to stat call. */
1946 bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
1951 if (abfd->arelt_data == NULL)
1953 bfd_set_error (bfd_error_invalid_operation);
1957 hdr = arch_hdr (abfd);
1959 #define foo(arelt, stelt, size) \
1960 buf->stelt = strtol (hdr->arelt, &aloser, size); \
1961 if (aloser == hdr->arelt) \
1964 /* Some platforms support special notations for large IDs. */
1965 #ifdef HPUX_LARGE_AR_IDS
1966 # define foo2(arelt, stelt, size) \
1967 if (hdr->arelt[5] == ' ') \
1969 foo (arelt, stelt, size); \
1974 for (buf->stelt = cnt = 0; cnt < 5; ++cnt) \
1976 if (hdr->arelt[cnt] < ' ' || hdr->arelt[cnt] > ' ' + 0x3f) \
1979 buf->stelt += hdr->arelt[cnt] - ' '; \
1981 if (hdr->arelt[5] < '@' || hdr->arelt[5] > '@' + 3) \
1984 buf->stelt += hdr->arelt[5] - '@'; \
1987 # define foo2(arelt, stelt, size) foo (arelt, stelt, size)
1990 foo (ar_date, st_mtime, 10);
1991 foo2 (ar_uid, st_uid, 10);
1992 foo2 (ar_gid, st_gid, 10);
1993 foo (ar_mode, st_mode, 8);
1995 buf->st_size = arch_eltdata (abfd)->parsed_size;
2001 bfd_dont_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
2003 /* FIXME: This interacts unpleasantly with ar's quick-append option.
2004 Fortunately ic960 users will never use that option. Fixing this
2005 is very hard; fortunately I know how to do it and will do so once
2006 intel's release is out the door. */
2008 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
2010 const char *filename;
2011 size_t maxlen = ar_maxnamelen (abfd);
2013 if ((bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
2015 bfd_bsd_truncate_arname (abfd, pathname, arhdr);
2019 filename = normalize (abfd, pathname);
2020 if (filename == NULL)
2026 length = strlen (filename);
2028 if (length <= maxlen)
2029 memcpy (hdr->ar_name, filename, length);
2031 /* Add the padding character if there is room for it. */
2033 || (length == maxlen && length < sizeof hdr->ar_name))
2034 (hdr->ar_name)[length] = ar_padchar (abfd);
2038 bfd_bsd_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
2040 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
2042 const char *filename = lbasename (pathname);
2043 size_t maxlen = ar_maxnamelen (abfd);
2045 length = strlen (filename);
2047 if (length <= maxlen)
2048 memcpy (hdr->ar_name, filename, length);
2051 /* pathname: meet procrustes */
2052 memcpy (hdr->ar_name, filename, maxlen);
2056 if (length < maxlen)
2057 (hdr->ar_name)[length] = ar_padchar (abfd);
2060 /* Store name into ar header. Truncates the name to fit.
2061 1> strip pathname to be just the basename.
2062 2> if it's short enuf to fit, stuff it in.
2063 3> If it doesn't end with .o, truncate it to fit
2064 4> truncate it before the .o, append .o, stuff THAT in. */
2066 /* This is what gnu ar does. It's better but incompatible with the
2070 bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
2072 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
2074 const char *filename = lbasename (pathname);
2075 size_t maxlen = ar_maxnamelen (abfd);
2077 length = strlen (filename);
2079 if (length <= maxlen)
2080 memcpy (hdr->ar_name, filename, length);
2083 /* pathname: meet procrustes. */
2084 memcpy (hdr->ar_name, filename, maxlen);
2085 if ((filename[length - 2] == '.') && (filename[length - 1] == 'o'))
2087 hdr->ar_name[maxlen - 2] = '.';
2088 hdr->ar_name[maxlen - 1] = 'o';
2094 (hdr->ar_name)[length] = ar_padchar (abfd);
2097 /* The BFD is open for write and has its format set to bfd_archive. */
2100 _bfd_write_archive_contents (bfd *arch)
2103 char *etable = NULL;
2104 bfd_size_type elength = 0;
2105 const char *ename = NULL;
2106 bfd_boolean makemap = bfd_has_map (arch);
2107 /* If no .o's, don't bother to make a map. */
2108 bfd_boolean hasobjects = FALSE;
2109 bfd_size_type wrote;
2113 /* Verify the viability of all entries; if any of them live in the
2114 filesystem (as opposed to living in an archive open for input)
2115 then construct a fresh ar_hdr for them. */
2116 for (current = arch->archive_head;
2118 current = current->archive_next)
2120 /* This check is checking the bfds for the objects we're reading
2121 from (which are usually either an object file or archive on
2122 disk), not the archive entries we're writing to. We don't
2123 actually create bfds for the archive members, we just copy
2124 them byte-wise when we write out the archive. */
2125 if (bfd_write_p (current))
2127 bfd_set_error (bfd_error_invalid_operation);
2130 if (!current->arelt_data)
2132 current->arelt_data =
2133 bfd_ar_hdr_from_filesystem (arch, current->filename, current);
2134 if (!current->arelt_data)
2137 /* Put in the file name. */
2138 BFD_SEND (arch, _bfd_truncate_arname,
2139 (arch, current->filename, (char *) arch_hdr (current)));
2142 if (makemap && ! hasobjects)
2143 { /* Don't bother if we won't make a map! */
2144 if ((bfd_check_format (current, bfd_object)))
2149 if (!BFD_SEND (arch, _bfd_construct_extended_name_table,
2150 (arch, &etable, &elength, &ename)))
2153 if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0)
2156 if (bfd_is_thin_archive (arch))
2158 wrote = bfd_bwrite (armag, SARMAG, arch);
2159 if (wrote != SARMAG)
2162 if (makemap && hasobjects)
2164 if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength))
2172 memset (&hdr, ' ', sizeof (struct ar_hdr));
2173 memcpy (hdr.ar_name, ename, strlen (ename));
2174 /* Round size up to even number in archive header. */
2175 if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size),
2176 (elength + 1) & ~(bfd_size_type) 1))
2178 memcpy (hdr.ar_fmag, ARFMAG, 2);
2179 if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2180 != sizeof (struct ar_hdr))
2181 || bfd_bwrite (etable, elength, arch) != elength)
2183 if ((elength % 2) == 1)
2185 if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)
2190 for (current = arch->archive_head;
2192 current = current->archive_next)
2194 char buffer[DEFAULT_BUFFERSIZE];
2195 bfd_size_type remaining = arelt_size (current);
2197 /* Write ar header. */
2198 if (!_bfd_write_ar_hdr (arch, current))
2200 if (bfd_is_thin_archive (arch))
2202 if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
2207 unsigned int amt = DEFAULT_BUFFERSIZE;
2209 if (amt > remaining)
2212 if (bfd_bread (buffer, amt, current) != amt)
2214 if (bfd_get_error () != bfd_error_system_call)
2215 bfd_set_error (bfd_error_file_truncated);
2218 if (bfd_bwrite (buffer, amt, arch) != amt)
2223 if ((arelt_size (current) % 2) == 1)
2225 if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)
2230 if (makemap && hasobjects)
2232 /* Verify the timestamp in the archive file. If it would not be
2233 accepted by the linker, rewrite it until it would be. If
2234 anything odd happens, break out and just return. (The
2235 Berkeley linker checks the timestamp and refuses to read the
2236 table-of-contents if it is >60 seconds less than the file's
2237 modified-time. That painful hack requires this painful hack. */
2241 if (bfd_update_armap_timestamp (arch))
2243 (*_bfd_error_handler)
2244 (_("Warning: writing archive was slow: rewriting timestamp\n"));
2246 while (++tries < 6);
2252 bfd_set_error (bfd_error_on_input, current, bfd_get_error ());
2256 /* Note that the namidx for the first symbol is 0. */
2259 _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
2261 char *first_name = NULL;
2263 file_ptr elt_no = 0;
2264 struct orl *map = NULL;
2265 unsigned int orl_max = 1024; /* Fine initial default. */
2266 unsigned int orl_count = 0;
2268 asymbol **syms = NULL;
2273 /* Dunno if this is the best place for this info... */
2275 elength += sizeof (struct ar_hdr);
2276 elength += elength % 2;
2278 amt = orl_max * sizeof (struct orl);
2279 map = (struct orl *) bfd_malloc (amt);
2283 /* We put the symbol names on the arch objalloc, and then discard
2285 first_name = (char *) bfd_alloc (arch, 1);
2286 if (first_name == NULL)
2289 /* Drop all the files called __.SYMDEF, we're going to make our own. */
2290 while (arch->archive_head
2291 && strcmp (arch->archive_head->filename, "__.SYMDEF") == 0)
2292 arch->archive_head = arch->archive_head->archive_next;
2294 /* Map over each element. */
2295 for (current = arch->archive_head;
2297 current = current->archive_next, elt_no++)
2299 if (bfd_check_format (current, bfd_object)
2300 && (bfd_get_file_flags (current) & HAS_SYMS) != 0)
2306 storage = bfd_get_symtab_upper_bound (current);
2312 if (storage > syms_max)
2317 syms = (asymbol **) bfd_malloc (syms_max);
2321 symcount = bfd_canonicalize_symtab (current, syms);
2325 /* Now map over all the symbols, picking out the ones we
2327 for (src_count = 0; src_count < symcount; src_count++)
2329 flagword flags = (syms[src_count])->flags;
2330 asection *sec = syms[src_count]->section;
2332 if (((flags & (BSF_GLOBAL
2335 | BSF_GNU_UNIQUE)) != 0
2336 || bfd_is_com_section (sec))
2337 && ! bfd_is_und_section (sec))
2339 bfd_size_type namelen;
2340 struct orl *new_map;
2342 /* This symbol will go into the archive header. */
2343 if (orl_count == orl_max)
2346 amt = orl_max * sizeof (struct orl);
2347 new_map = (struct orl *) bfd_realloc (map, amt);
2348 if (new_map == NULL)
2354 namelen = strlen (syms[src_count]->name);
2355 amt = sizeof (char *);
2356 map[orl_count].name = (char **) bfd_alloc (arch, amt);
2357 if (map[orl_count].name == NULL)
2359 *(map[orl_count].name) = (char *) bfd_alloc (arch,
2361 if (*(map[orl_count].name) == NULL)
2363 strcpy (*(map[orl_count].name), syms[src_count]->name);
2364 map[orl_count].u.abfd = current;
2365 map[orl_count].namidx = stridx;
2367 stridx += namelen + 1;
2373 /* Now ask the BFD to free up any cached information, so we
2374 don't fill all of memory with symbol tables. */
2375 if (! bfd_free_cached_info (current))
2380 /* OK, now we have collected all the data, let's write them out. */
2381 ret = BFD_SEND (arch, write_armap,
2382 (arch, elength, map, orl_count, stridx));
2388 if (first_name != NULL)
2389 bfd_release (arch, first_name);
2398 if (first_name != NULL)
2399 bfd_release (arch, first_name);
2405 bsd_write_armap (bfd *arch,
2406 unsigned int elength,
2408 unsigned int orl_count,
2411 int padit = stridx & 1;
2412 unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE;
2413 unsigned int stringsize = stridx + padit;
2414 /* Include 8 bytes to store ranlibsize and stringsize in output. */
2415 unsigned int mapsize = ranlibsize + stringsize + 8;
2417 bfd *current = arch->archive_head;
2418 bfd *last_elt = current; /* Last element arch seen. */
2424 firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
2426 /* If deterministic, we use 0 as the timestamp in the map.
2427 Some linkers may require that the archive filesystem modification
2428 time is less than (or near to) the archive map timestamp. Those
2429 linkers should not be used with deterministic mode. (GNU ld and
2430 Gold do not have this restriction.) */
2431 bfd_ardata (arch)->armap_timestamp = 0;
2434 if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0)
2436 struct stat statbuf;
2438 if (stat (arch->filename, &statbuf) == 0)
2439 bfd_ardata (arch)->armap_timestamp = (statbuf.st_mtime
2440 + ARMAP_TIME_OFFSET);
2445 memset (&hdr, ' ', sizeof (struct ar_hdr));
2446 memcpy (hdr.ar_name, RANLIBMAG, strlen (RANLIBMAG));
2447 bfd_ardata (arch)->armap_datepos = (SARMAG
2448 + offsetof (struct ar_hdr, ar_date[0]));
2449 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2450 bfd_ardata (arch)->armap_timestamp);
2451 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", uid);
2452 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", gid);
2453 if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))
2455 memcpy (hdr.ar_fmag, ARFMAG, 2);
2456 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2457 != sizeof (struct ar_hdr))
2459 H_PUT_32 (arch, ranlibsize, temp);
2460 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
2463 for (count = 0; count < orl_count; count++)
2465 unsigned int offset;
2466 bfd_byte buf[BSD_SYMDEF_SIZE];
2468 if (map[count].u.abfd != last_elt)
2472 struct areltdata *ared = arch_eltdata (current);
2474 firstreal += (ared->parsed_size + ared->extra_size
2475 + sizeof (struct ar_hdr));
2476 firstreal += firstreal % 2;
2477 current = current->archive_next;
2479 while (current != map[count].u.abfd);
2482 /* The archive file format only has 4 bytes to store the offset
2483 of the member. Check to make sure that firstreal has not grown
2485 offset = (unsigned int) firstreal;
2486 if (firstreal != (file_ptr) offset)
2488 bfd_set_error (bfd_error_file_truncated);
2493 H_PUT_32 (arch, map[count].namidx, buf);
2494 H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE);
2495 if (bfd_bwrite (buf, BSD_SYMDEF_SIZE, arch)
2500 /* Now write the strings themselves. */
2501 H_PUT_32 (arch, stringsize, temp);
2502 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
2504 for (count = 0; count < orl_count; count++)
2506 size_t len = strlen (*map[count].name) + 1;
2508 if (bfd_bwrite (*map[count].name, len, arch) != len)
2512 /* The spec sez this should be a newline. But in order to be
2513 bug-compatible for sun's ar we use a null. */
2516 if (bfd_bwrite ("", 1, arch) != 1)
2523 /* At the end of archive file handling, update the timestamp in the
2524 file, so the linker will accept it.
2526 Return TRUE if the timestamp was OK, or an unusual problem happened.
2527 Return FALSE if we updated the timestamp. */
2530 _bfd_archive_bsd_update_armap_timestamp (bfd *arch)
2532 struct stat archstat;
2535 /* If creating deterministic archives, just leave the timestamp as-is. */
2536 if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) != 0)
2539 /* Flush writes, get last-write timestamp from file, and compare it
2540 to the timestamp IN the file. */
2542 if (bfd_stat (arch, &archstat) == -1)
2544 bfd_perror (_("Reading archive file mod timestamp"));
2546 /* Can't read mod time for some reason. */
2549 if (((long) archstat.st_mtime) <= bfd_ardata (arch)->armap_timestamp)
2550 /* OK by the linker's rules. */
2553 /* Update the timestamp. */
2554 bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET;
2556 /* Prepare an ASCII version suitable for writing. */
2557 memset (hdr.ar_date, ' ', sizeof (hdr.ar_date));
2558 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2559 bfd_ardata (arch)->armap_timestamp);
2561 /* Write it into the file. */
2562 bfd_ardata (arch)->armap_datepos = (SARMAG
2563 + offsetof (struct ar_hdr, ar_date[0]));
2564 if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0
2565 || (bfd_bwrite (hdr.ar_date, sizeof (hdr.ar_date), arch)
2566 != sizeof (hdr.ar_date)))
2568 bfd_perror (_("Writing updated armap timestamp"));
2570 /* Some error while writing. */
2574 /* We updated the timestamp successfully. */
2578 /* A coff armap looks like :
2580 struct ar_hdr with name = '/'
2582 offset of file for symbol 0
2583 offset of file for symbol 1
2585 offset of file for symbol n-1
2592 coff_write_armap (bfd *arch,
2593 unsigned int elength,
2595 unsigned int symbol_count,
2598 /* The size of the ranlib is the number of exported symbols in the
2599 archive * the number of bytes in an int, + an int for the count. */
2600 unsigned int ranlibsize = (symbol_count * 4) + 4;
2601 unsigned int stringsize = stridx;
2602 unsigned int mapsize = stringsize + ranlibsize;
2603 file_ptr archive_member_file_ptr;
2604 bfd *current = arch->archive_head;
2607 int padit = mapsize & 1;
2612 /* Work out where the first object file will go in the archive. */
2613 archive_member_file_ptr = (mapsize
2615 + sizeof (struct ar_hdr)
2618 memset (&hdr, ' ', sizeof (struct ar_hdr));
2619 hdr.ar_name[0] = '/';
2620 if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))
2622 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2623 ((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0
2624 ? time (NULL) : 0));
2625 /* This, at least, is what Intel coff sets the values to. */
2626 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", 0);
2627 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", 0);
2628 _bfd_ar_spacepad (hdr.ar_mode, sizeof (hdr.ar_mode), "%-7lo", 0);
2629 memcpy (hdr.ar_fmag, ARFMAG, 2);
2631 /* Write the ar header for this item and the number of symbols. */
2632 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2633 != sizeof (struct ar_hdr))
2636 if (!bfd_write_bigendian_4byte_int (arch, symbol_count))
2639 /* Two passes, first write the file offsets for each symbol -
2640 remembering that each offset is on a two byte boundary. */
2642 /* Write out the file offset for the file associated with each
2643 symbol, and remember to keep the offsets padded out. */
2645 current = arch->archive_head;
2647 while (current != NULL && count < symbol_count)
2649 /* For each symbol which is used defined in this object, write
2650 out the object file's address in the archive. */
2652 while (count < symbol_count && map[count].u.abfd == current)
2654 unsigned int offset = (unsigned int) archive_member_file_ptr;
2656 /* Catch an attempt to grow an archive past its 4Gb limit. */
2657 if (archive_member_file_ptr != (file_ptr) offset)
2659 bfd_set_error (bfd_error_file_truncated);
2662 if (!bfd_write_bigendian_4byte_int (arch, offset))
2666 archive_member_file_ptr += sizeof (struct ar_hdr);
2667 if (! bfd_is_thin_archive (arch))
2669 /* Add size of this archive entry. */
2670 archive_member_file_ptr += arelt_size (current);
2671 /* Remember about the even alignment. */
2672 archive_member_file_ptr += archive_member_file_ptr % 2;
2674 current = current->archive_next;
2677 /* Now write the strings themselves. */
2678 for (count = 0; count < symbol_count; count++)
2680 size_t len = strlen (*map[count].name) + 1;
2682 if (bfd_bwrite (*map[count].name, len, arch) != len)
2686 /* The spec sez this should be a newline. But in order to be
2687 bug-compatible for arc960 we use a null. */
2690 if (bfd_bwrite ("", 1, arch) != 1)
2698 archive_close_worker (void **slot, void *inf ATTRIBUTE_UNUSED)
2700 struct ar_cache *ent = (struct ar_cache *) *slot;
2702 bfd_close_all_done (ent->arbfd);
2707 _bfd_archive_close_and_cleanup (bfd *abfd)
2709 if (bfd_read_p (abfd) && abfd->format == bfd_archive)
2715 /* Close nested archives (if this bfd is a thin archive). */
2716 for (nbfd = abfd->nested_archives; nbfd; nbfd = next)
2718 next = nbfd->archive_next;
2722 htab = bfd_ardata (abfd)->cache;
2725 htab_traverse_noresize (htab, archive_close_worker, NULL);
2727 bfd_ardata (abfd)->cache = NULL;
2730 else if (arch_eltdata (abfd) != NULL)
2732 struct areltdata *ared = arch_eltdata (abfd);
2733 htab_t htab = (htab_t) ared->parent_cache;
2737 struct ar_cache ent;
2740 ent.ptr = ared->key;
2741 slot = htab_find_slot (htab, &ent, NO_INSERT);
2744 BFD_ASSERT (((struct ar_cache *) *slot)->arbfd == abfd);
2745 htab_clear_slot (htab, slot);