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
4 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 2 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 Archive contents of output BFDs are chained through the
46 <<next>> pointer in a BFD. The first one is findable through
47 the <<archive_head>> slot of the archive. Set it with
48 <<bfd_set_archive_head>> (q.v.). A given BFD may be in only one
49 open output archive at a time.
51 As expected, the BFD archive code is more general than the
52 archive code of any given environment. BFD archives may
53 contain files of different formats (e.g., a.out and coff) and
54 even different architectures. You may even place archives
55 recursively into archives!
57 This can cause unexpected confusion, since some archive
58 formats are more expressive than others. For instance, Intel
59 COFF archives can preserve long filenames; SunOS a.out archives
60 cannot. If you move a file from the first to the second
61 format and back again, the filename may be truncated.
62 Likewise, different a.out environments have different
63 conventions as to how they truncate filenames, whether they
64 preserve directory names in filenames, etc. When
65 interoperating with native tools, be sure your files are
68 Beware: most of these formats do not react well to the
69 presence of spaces in filenames. We do the best we can, but
70 can't always handle this case due to restrictions in the format of
71 archives. Many Unix utilities are braindead in regards to
72 spaces and such in filenames anyway, so this shouldn't be much
75 Archives are supported in BFD in <<archive.c>>.
80 o - all archive elements start on an even boundary, newline padded;
81 o - all arch headers are char *;
82 o - all arch headers are the same size (across architectures).
85 /* Some formats provide a way to cram a long filename into the short
86 (16 chars) space provided by a BSD archive. The trick is: make a
87 special "file" in the front of the archive, sort of like the SYMDEF
88 entry. If the filename is too long to fit, put it in the extended
89 name table, and use its index as the filename. To prevent
90 confusion prepend the index with a space. This means you can't
91 have filenames that start with a space, but then again, many Unix
92 utilities can't handle that anyway.
94 This scheme unfortunately requires that you stand on your head in
95 order to write an archive since you need to put a magic file at the
96 front, and need to touch every entry to do so. C'est la vie.
98 We support two variants of this idea:
99 The SVR4 format (extended name table is named "//"),
100 and an extended pseudo-BSD variant (extended name table is named
101 "ARFILENAMES/"). The origin of the latter format is uncertain.
103 BSD 4.4 uses a third scheme: It writes a long filename
104 directly after the header. This allows 'ar q' to work.
105 We currently can read BSD 4.4 archives, but not write them.
108 /* Summary of archive member names:
110 Symbol table (must be first):
111 "__.SYMDEF " - Symbol table, Berkeley style, produced by ranlib.
112 "/ " - Symbol table, system 5 style.
114 Long name table (must be before regular file members):
115 "// " - Long name table, System 5 R4 style.
116 "ARFILENAMES/ " - Long name table, non-standard extended BSD (not BSD 4.4).
118 Regular file members with short names:
119 "filename.o/ " - Regular file, System 5 style (embedded spaces ok).
120 "filename.o " - Regular file, Berkeley style (no embedded spaces).
122 Regular files with long names (or embedded spaces, for BSD variants):
123 "/18 " - SVR4 style, name at offset 18 in name table.
124 "#1/23 " - Long name (or embedded spaces) 23 characters long,
125 BSD 4.4 style, full name follows header.
126 Implemented for reading, not writing.
127 " 18 " - Long name 18 characters long, extended pseudo-BSD.
134 #include "aout/ranlib.h"
135 #include "safe-ctype.h"
142 /* We keep a cache of archive filepointers to archive elements to
143 speed up searching the archive by filepos. We only add an entry to
144 the cache when we actually read one. We also don't sort the cache;
145 it's generally short enough to search linearly.
146 Note that the pointers here point to the front of the ar_hdr, not
147 to the front of the contents! */
153 #define ar_padchar(abfd) ((abfd)->xvec->ar_pad_char)
154 #define ar_maxnamelen(abfd) ((abfd)->xvec->ar_max_namelen)
156 #define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data))
157 #define arch_hdr(bfd) ((struct ar_hdr *) arch_eltdata(bfd)->arch_header)
160 _bfd_ar_spacepad (char *p, size_t n, const char *fmt, long val)
164 snprintf (buf, sizeof (buf), fmt, val);
168 memcpy (p, buf, len);
169 memset (p + len, ' ', n - len);
176 _bfd_generic_mkarchive (bfd *abfd)
178 bfd_size_type amt = sizeof (struct artdata);
180 abfd->tdata.aout_ar_data = bfd_zalloc (abfd, amt);
181 if (bfd_ardata (abfd) == NULL)
184 bfd_ardata (abfd)->cache = NULL;
185 bfd_ardata (abfd)->archive_head = NULL;
186 bfd_ardata (abfd)->symdefs = NULL;
187 bfd_ardata (abfd)->extended_names = NULL;
188 bfd_ardata (abfd)->tdata = NULL;
198 symindex bfd_get_next_mapent
199 (bfd *abfd, symindex previous, carsym **sym);
202 Step through archive @var{abfd}'s symbol table (if it
203 has one). Successively update @var{sym} with the next symbol's
204 information, returning that symbol's (internal) index into the
207 Supply <<BFD_NO_MORE_SYMBOLS>> as the @var{previous} entry to get
208 the first one; returns <<BFD_NO_MORE_SYMBOLS>> when you've already
211 A <<carsym>> is a canonical archive symbol. The only
212 user-visible element is its name, a null-terminated string.
216 bfd_get_next_mapent (bfd *abfd, symindex prev, carsym **entry)
218 if (!bfd_has_map (abfd))
220 bfd_set_error (bfd_error_invalid_operation);
221 return BFD_NO_MORE_SYMBOLS;
224 if (prev == BFD_NO_MORE_SYMBOLS)
228 if (prev >= bfd_ardata (abfd)->symdef_count)
229 return BFD_NO_MORE_SYMBOLS;
231 *entry = (bfd_ardata (abfd)->symdefs + prev);
235 /* To be called by backends only. */
238 _bfd_create_empty_archive_element_shell (bfd *obfd)
240 return _bfd_new_bfd_contained_in (obfd);
248 bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);
251 Set the head of the chain of
252 BFDs contained in the archive @var{output} to @var{new_head}.
256 bfd_set_archive_head (bfd *output_archive, bfd *new_head)
258 output_archive->archive_head = new_head;
263 _bfd_look_for_bfd_in_cache (bfd *arch_bfd, file_ptr filepos)
265 htab_t hash_table = bfd_ardata (arch_bfd)->cache;
271 struct ar_cache *entry = (struct ar_cache *) htab_find (hash_table, &m);
282 hash_file_ptr (const PTR p)
284 return (hashval_t) (((struct ar_cache *) p)->ptr);
287 /* Returns non-zero if P1 and P2 are equal. */
290 eq_file_ptr (const PTR p1, const PTR p2)
292 struct ar_cache *arc1 = (struct ar_cache *) p1;
293 struct ar_cache *arc2 = (struct ar_cache *) p2;
294 return arc1->ptr == arc2->ptr;
297 /* Kind of stupid to call cons for each one, but we don't do too many. */
300 _bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt)
302 struct ar_cache *cache;
303 htab_t hash_table = bfd_ardata (arch_bfd)->cache;
305 /* If the hash table hasn't been created, create it. */
306 if (hash_table == NULL)
308 hash_table = htab_create_alloc (16, hash_file_ptr, eq_file_ptr,
310 if (hash_table == NULL)
312 bfd_ardata (arch_bfd)->cache = hash_table;
315 /* Insert new_elt into the hash table by filepos. */
316 cache = bfd_zalloc (arch_bfd, sizeof (struct ar_cache));
317 cache->ptr = filepos;
318 cache->arbfd = new_elt;
319 *htab_find_slot (hash_table, (const void *) cache, INSERT) = cache;
324 /* The name begins with space. Hence the rest of the name is an index into
328 get_extended_arelt_filename (bfd *arch, const char *name)
330 unsigned long index = 0;
332 /* Should extract string so that I can guarantee not to overflow into
333 the next region, but I'm too lazy. */
335 /* Skip first char, which is '/' in SVR4 or ' ' in some other variants. */
336 index = strtol (name + 1, NULL, 10);
339 bfd_set_error (bfd_error_malformed_archive);
343 return bfd_ardata (arch)->extended_names + index;
346 /* This functions reads an arch header and returns an areltdata pointer, or
349 Presumes the file pointer is already in the right place (ie pointing
350 to the ar_hdr in the file). Moves the file pointer; on success it
351 should be pointing to the front of the file contents; on failure it
352 could have been moved arbitrarily. */
355 _bfd_generic_read_ar_hdr (bfd *abfd)
357 return _bfd_generic_read_ar_hdr_mag (abfd, NULL);
360 /* Alpha ECOFF uses an optional different ARFMAG value, so we have a
361 variant of _bfd_generic_read_ar_hdr which accepts a magic string. */
364 _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
367 char *hdrp = (char *) &hdr;
369 struct areltdata *ared;
370 char *filename = NULL;
371 bfd_size_type namelen = 0;
372 bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
375 if (bfd_bread (hdrp, sizeof (struct ar_hdr), abfd) != sizeof (struct ar_hdr))
377 if (bfd_get_error () != bfd_error_system_call)
378 bfd_set_error (bfd_error_no_more_archived_files);
381 if (strncmp (hdr.ar_fmag, ARFMAG, 2) != 0
383 || strncmp (hdr.ar_fmag, mag, 2) != 0))
385 bfd_set_error (bfd_error_malformed_archive);
390 parsed_size = strtol (hdr.ar_size, NULL, 10);
393 bfd_set_error (bfd_error_malformed_archive);
397 /* Extract the filename from the archive - there are two ways to
398 specify an extended name table, either the first char of the
399 name is a space, or it's a slash. */
400 if ((hdr.ar_name[0] == '/'
401 || (hdr.ar_name[0] == ' '
402 && memchr (hdr.ar_name, '/', ar_maxnamelen (abfd)) == NULL))
403 && bfd_ardata (abfd)->extended_names != NULL)
405 filename = get_extended_arelt_filename (abfd, hdr.ar_name);
406 if (filename == NULL)
408 bfd_set_error (bfd_error_malformed_archive);
412 /* BSD4.4-style long filename.
413 Only implemented for reading, so far! */
414 else if (hdr.ar_name[0] == '#'
415 && hdr.ar_name[1] == '1'
416 && hdr.ar_name[2] == '/'
417 && ISDIGIT (hdr.ar_name[3]))
419 /* BSD-4.4 extended name */
420 namelen = atoi (&hdr.ar_name[3]);
421 allocsize += namelen + 1;
422 parsed_size -= namelen;
424 allocptr = bfd_zalloc (abfd, allocsize);
425 if (allocptr == NULL)
428 + sizeof (struct areltdata)
429 + sizeof (struct ar_hdr));
430 if (bfd_bread (filename, namelen, abfd) != namelen)
432 if (bfd_get_error () != bfd_error_system_call)
433 bfd_set_error (bfd_error_no_more_archived_files);
436 filename[namelen] = '\0';
440 /* We judge the end of the name by looking for '/' or ' '.
441 Note: The SYSV format (terminated by '/') allows embedded
442 spaces, so only look for ' ' if we don't find '/'. */
445 e = memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
448 e = memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
450 e = memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
454 namelen = e - hdr.ar_name;
457 /* If we didn't find a termination character, then the name
458 must be the entire field. */
459 namelen = ar_maxnamelen (abfd);
462 allocsize += namelen + 1;
467 allocptr = bfd_zalloc (abfd, allocsize);
468 if (allocptr == NULL)
472 ared = (struct areltdata *) allocptr;
474 ared->arch_header = allocptr + sizeof (struct areltdata);
475 memcpy (ared->arch_header, &hdr, sizeof (struct ar_hdr));
476 ared->parsed_size = parsed_size;
478 if (filename != NULL)
479 ared->filename = filename;
482 ared->filename = allocptr + (sizeof (struct areltdata) +
483 sizeof (struct ar_hdr));
485 memcpy (ared->filename, hdr.ar_name, namelen);
486 ared->filename[namelen] = '\0';
492 /* This is an internal function; it's mainly used when indexing
493 through the archive symbol table, but also used to get the next
494 element, since it handles the bookkeeping so nicely for us. */
497 _bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos)
499 struct areltdata *new_areldata;
502 if (archive->my_archive)
504 filepos += archive->origin;
505 archive = archive->my_archive;
508 n_nfd = _bfd_look_for_bfd_in_cache (archive, filepos);
512 if (0 > bfd_seek (archive, filepos, SEEK_SET))
515 if ((new_areldata = _bfd_read_ar_hdr (archive)) == NULL)
518 n_nfd = _bfd_create_empty_archive_element_shell (archive);
521 bfd_release (archive, new_areldata);
525 n_nfd->origin = bfd_tell (archive);
526 n_nfd->arelt_data = new_areldata;
527 n_nfd->filename = new_areldata->filename;
529 if (_bfd_add_bfd_to_archive_cache (archive, filepos, n_nfd))
533 bfd_release (archive, n_nfd);
534 bfd_release (archive, new_areldata);
538 /* Return the BFD which is referenced by the symbol in ABFD indexed by
539 INDEX. INDEX should have been returned by bfd_get_next_mapent. */
542 _bfd_generic_get_elt_at_index (bfd *abfd, symindex index)
546 entry = bfd_ardata (abfd)->symdefs + index;
547 return _bfd_get_elt_at_filepos (abfd, entry->file_offset);
552 bfd_openr_next_archived_file
555 bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous);
558 Provided a BFD, @var{archive}, containing an archive and NULL, open
559 an input BFD on the first contained element and returns that.
560 Subsequent calls should pass
561 the archive and the previous return value to return a created
562 BFD to the next contained element. NULL is returned when there
567 bfd_openr_next_archived_file (bfd *archive, bfd *last_file)
569 if ((bfd_get_format (archive) != bfd_archive) ||
570 (archive->direction == write_direction))
572 bfd_set_error (bfd_error_invalid_operation);
576 return BFD_SEND (archive,
577 openr_next_archived_file, (archive, last_file));
581 bfd_generic_openr_next_archived_file (bfd *archive, bfd *last_file)
586 filestart = bfd_ardata (archive)->first_file_filepos;
589 unsigned int size = arelt_size (last_file);
590 filestart = last_file->origin + size;
591 if (archive->my_archive)
592 filestart -= archive->origin;
593 /* Pad to an even boundary...
594 Note that last_file->origin can be odd in the case of
595 BSD-4.4-style element with a long odd size. */
596 filestart += filestart % 2;
599 return _bfd_get_elt_at_filepos (archive, filestart);
603 bfd_generic_archive_p (bfd *abfd)
605 struct artdata *tdata_hold;
606 char armag[SARMAG + 1];
609 if (bfd_bread (armag, SARMAG, abfd) != SARMAG)
611 if (bfd_get_error () != bfd_error_system_call)
612 bfd_set_error (bfd_error_wrong_format);
616 if (strncmp (armag, ARMAG, SARMAG) != 0 &&
617 strncmp (armag, ARMAGB, SARMAG) != 0)
620 tdata_hold = bfd_ardata (abfd);
622 amt = sizeof (struct artdata);
623 bfd_ardata (abfd) = bfd_zalloc (abfd, amt);
624 if (bfd_ardata (abfd) == NULL)
626 bfd_ardata (abfd) = tdata_hold;
630 bfd_ardata (abfd)->first_file_filepos = SARMAG;
631 bfd_ardata (abfd)->cache = NULL;
632 bfd_ardata (abfd)->archive_head = NULL;
633 bfd_ardata (abfd)->symdefs = NULL;
634 bfd_ardata (abfd)->extended_names = NULL;
635 bfd_ardata (abfd)->tdata = NULL;
637 if (!BFD_SEND (abfd, _bfd_slurp_armap, (abfd))
638 || !BFD_SEND (abfd, _bfd_slurp_extended_name_table, (abfd)))
640 if (bfd_get_error () != bfd_error_system_call)
641 bfd_set_error (bfd_error_wrong_format);
642 bfd_release (abfd, bfd_ardata (abfd));
643 bfd_ardata (abfd) = tdata_hold;
647 if (bfd_has_map (abfd))
651 /* This archive has a map, so we may presume that the contents
652 are object files. Make sure that if the first file in the
653 archive can be recognized as an object file, it is for this
654 target. If not, assume that this is the wrong format. If
655 the first file is not an object file, somebody is doing
656 something weird, and we permit it so that ar -t will work.
658 This is done because any normal format will recognize any
659 normal archive, regardless of the format of the object files.
660 We do accept an empty archive. */
662 first = bfd_openr_next_archived_file (abfd, NULL);
667 first->target_defaulted = FALSE;
669 if (bfd_check_format (first, bfd_object)
670 && first->xvec != abfd->xvec)
672 bfd_set_error (bfd_error_wrong_object_format);
673 bfd_ardata (abfd) = tdata_hold;
676 /* And we ought to close `first' here too. */
683 /* Some constants for a 32 bit BSD archive structure. We do not
684 support 64 bit archives presently; so far as I know, none actually
685 exist. Supporting them would require changing these constants, and
686 changing some H_GET_32 to H_GET_64. */
688 /* The size of an external symdef structure. */
689 #define BSD_SYMDEF_SIZE 8
691 /* The offset from the start of a symdef structure to the file offset. */
692 #define BSD_SYMDEF_OFFSET_SIZE 4
694 /* The size of the symdef count. */
695 #define BSD_SYMDEF_COUNT_SIZE 4
697 /* The size of the string count. */
698 #define BSD_STRING_COUNT_SIZE 4
700 /* Returns FALSE on error, TRUE otherwise. */
703 do_slurp_bsd_armap (bfd *abfd)
705 struct areltdata *mapdata;
706 unsigned int counter;
707 bfd_byte *raw_armap, *rbase;
708 struct artdata *ardata = bfd_ardata (abfd);
710 bfd_size_type parsed_size, amt;
713 mapdata = _bfd_read_ar_hdr (abfd);
716 parsed_size = mapdata->parsed_size;
717 bfd_release (abfd, mapdata); /* Don't need it any more. */
719 raw_armap = bfd_zalloc (abfd, parsed_size);
720 if (raw_armap == NULL)
723 if (bfd_bread (raw_armap, parsed_size, abfd) != parsed_size)
725 if (bfd_get_error () != bfd_error_system_call)
726 bfd_set_error (bfd_error_malformed_archive);
728 bfd_release (abfd, raw_armap);
732 ardata->symdef_count = H_GET_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE;
734 if (ardata->symdef_count * BSD_SYMDEF_SIZE >
735 parsed_size - BSD_SYMDEF_COUNT_SIZE)
737 /* Probably we're using the wrong byte ordering. */
738 bfd_set_error (bfd_error_wrong_format);
743 rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE;
744 stringbase = ((char *) rbase
745 + ardata->symdef_count * BSD_SYMDEF_SIZE
746 + BSD_STRING_COUNT_SIZE);
747 amt = ardata->symdef_count * sizeof (carsym);
748 ardata->symdefs = bfd_alloc (abfd, amt);
749 if (!ardata->symdefs)
752 for (counter = 0, set = ardata->symdefs;
753 counter < ardata->symdef_count;
754 counter++, set++, rbase += BSD_SYMDEF_SIZE)
756 set->name = H_GET_32 (abfd, rbase) + stringbase;
757 set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
760 ardata->first_file_filepos = bfd_tell (abfd);
761 /* Pad to an even boundary if you have to. */
762 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
763 /* FIXME, we should provide some way to free raw_ardata when
764 we are done using the strings from it. For now, it seems
765 to be allocated on an objalloc anyway... */
766 bfd_has_map (abfd) = TRUE;
770 /* Returns FALSE on error, TRUE otherwise. */
773 do_slurp_coff_armap (bfd *abfd)
775 struct areltdata *mapdata;
776 int *raw_armap, *rawptr;
777 struct artdata *ardata = bfd_ardata (abfd);
779 bfd_size_type stringsize;
780 unsigned int parsed_size;
782 bfd_size_type nsymz; /* Number of symbols in armap. */
783 bfd_vma (*swap) (const void *);
784 char int_buf[sizeof (long)];
785 bfd_size_type carsym_size, ptrsize;
788 mapdata = _bfd_read_ar_hdr (abfd);
791 parsed_size = mapdata->parsed_size;
792 bfd_release (abfd, mapdata); /* Don't need it any more. */
794 if (bfd_bread (int_buf, 4, abfd) != 4)
796 if (bfd_get_error () != bfd_error_system_call)
797 bfd_set_error (bfd_error_malformed_archive);
800 /* It seems that all numeric information in a coff archive is always
801 in big endian format, nomatter the host or target. */
803 nsymz = bfd_getb32 (int_buf);
804 stringsize = parsed_size - (4 * nsymz) - 4;
806 /* ... except that some archive formats are broken, and it may be our
807 fault - the i960 little endian coff sometimes has big and sometimes
808 little, because our tools changed. Here's a horrible hack to clean
811 if (stringsize > 0xfffff
812 && bfd_get_arch (abfd) == bfd_arch_i960
813 && bfd_get_flavour (abfd) == bfd_target_coff_flavour)
815 /* This looks dangerous, let's do it the other way around. */
816 nsymz = bfd_getl32 (int_buf);
817 stringsize = parsed_size - (4 * nsymz) - 4;
821 /* The coff armap must be read sequentially. So we construct a
822 bsd-style one in core all at once, for simplicity. */
824 if (nsymz > ~ (bfd_size_type) 0 / sizeof (carsym))
827 carsym_size = (nsymz * sizeof (carsym));
828 ptrsize = (4 * nsymz);
830 if (carsym_size + stringsize + 1 <= carsym_size)
833 ardata->symdefs = bfd_zalloc (abfd, carsym_size + stringsize + 1);
834 if (ardata->symdefs == NULL)
836 carsyms = ardata->symdefs;
837 stringbase = ((char *) ardata->symdefs) + carsym_size;
839 /* Allocate and read in the raw offsets. */
840 raw_armap = bfd_alloc (abfd, ptrsize);
841 if (raw_armap == NULL)
842 goto release_symdefs;
843 if (bfd_bread (raw_armap, ptrsize, abfd) != ptrsize
844 || (bfd_bread (stringbase, stringsize, abfd) != stringsize))
846 if (bfd_get_error () != bfd_error_system_call)
847 bfd_set_error (bfd_error_malformed_archive);
848 goto release_raw_armap;
851 /* OK, build the carsyms. */
852 for (i = 0; i < nsymz; i++)
854 rawptr = raw_armap + i;
855 carsyms->file_offset = swap ((bfd_byte *) rawptr);
856 carsyms->name = stringbase;
857 stringbase += strlen (stringbase) + 1;
862 ardata->symdef_count = nsymz;
863 ardata->first_file_filepos = bfd_tell (abfd);
864 /* Pad to an even boundary if you have to. */
865 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
867 bfd_has_map (abfd) = TRUE;
868 bfd_release (abfd, raw_armap);
870 /* Check for a second archive header (as used by PE). */
872 struct areltdata *tmp;
874 bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET);
875 tmp = _bfd_read_ar_hdr (abfd);
878 if (tmp->arch_header[0] == '/'
879 && tmp->arch_header[1] == ' ')
881 ardata->first_file_filepos +=
882 (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1;
884 bfd_release (abfd, tmp);
891 bfd_release (abfd, raw_armap);
893 bfd_release (abfd, (ardata)->symdefs);
897 /* This routine can handle either coff-style or bsd-style armaps.
898 Returns FALSE on error, TRUE otherwise */
901 bfd_slurp_armap (bfd *abfd)
904 int i = bfd_bread (nextname, 16, abfd);
911 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
914 if (!strncmp (nextname, "__.SYMDEF ", 16)
915 || !strncmp (nextname, "__.SYMDEF/ ", 16)) /* old Linux archives */
916 return do_slurp_bsd_armap (abfd);
917 else if (!strncmp (nextname, "/ ", 16))
918 return do_slurp_coff_armap (abfd);
919 else if (!strncmp (nextname, "/SYM64/ ", 16))
921 /* 64bit ELF (Irix 6) archive. */
923 extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *);
924 return bfd_elf64_archive_slurp_armap (abfd);
926 bfd_set_error (bfd_error_wrong_format);
931 bfd_has_map (abfd) = FALSE;
935 /* Returns FALSE on error, TRUE otherwise. */
936 /* Flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
937 header is in a slightly different order and the map name is '/'.
938 This flavour is used by hp300hpux. */
940 #define HPUX_SYMDEF_COUNT_SIZE 2
943 bfd_slurp_bsd_armap_f2 (bfd *abfd)
945 struct areltdata *mapdata;
947 unsigned int counter;
948 bfd_byte *raw_armap, *rbase;
949 struct artdata *ardata = bfd_ardata (abfd);
951 unsigned int stringsize;
954 int i = bfd_bread (nextname, 16, abfd);
961 /* The archive has at least 16 bytes in it. */
962 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
965 if (!strncmp (nextname, "__.SYMDEF ", 16)
966 || !strncmp (nextname, "__.SYMDEF/ ", 16)) /* Old Linux archives. */
967 return do_slurp_bsd_armap (abfd);
969 if (strncmp (nextname, "/ ", 16))
971 bfd_has_map (abfd) = FALSE;
975 mapdata = _bfd_read_ar_hdr (abfd);
979 amt = mapdata->parsed_size;
980 raw_armap = bfd_zalloc (abfd, amt);
981 if (raw_armap == NULL)
984 bfd_release (abfd, mapdata);
988 if (bfd_bread (raw_armap, amt, abfd) != amt)
990 if (bfd_get_error () != bfd_error_system_call)
991 bfd_set_error (bfd_error_malformed_archive);
993 bfd_release (abfd, raw_armap);
997 ardata->symdef_count = H_GET_16 (abfd, raw_armap);
999 if (ardata->symdef_count * BSD_SYMDEF_SIZE
1000 > mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE)
1002 /* Probably we're using the wrong byte ordering. */
1003 bfd_set_error (bfd_error_wrong_format);
1009 stringsize = H_GET_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE);
1010 /* Skip sym count and string sz. */
1011 stringbase = ((char *) raw_armap
1012 + HPUX_SYMDEF_COUNT_SIZE
1013 + BSD_STRING_COUNT_SIZE);
1014 rbase = (bfd_byte *) stringbase + stringsize;
1015 amt = ardata->symdef_count * BSD_SYMDEF_SIZE;
1016 ardata->symdefs = bfd_alloc (abfd, amt);
1017 if (!ardata->symdefs)
1020 for (counter = 0, set = ardata->symdefs;
1021 counter < ardata->symdef_count;
1022 counter++, set++, rbase += BSD_SYMDEF_SIZE)
1024 set->name = H_GET_32 (abfd, rbase) + stringbase;
1025 set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
1028 ardata->first_file_filepos = bfd_tell (abfd);
1029 /* Pad to an even boundary if you have to. */
1030 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1031 /* FIXME, we should provide some way to free raw_ardata when
1032 we are done using the strings from it. For now, it seems
1033 to be allocated on an objalloc anyway... */
1034 bfd_has_map (abfd) = TRUE;
1038 /** Extended name table.
1040 Normally archives support only 14-character filenames.
1042 Intel has extended the format: longer names are stored in a special
1043 element (the first in the archive, or second if there is an armap);
1044 the name in the ar_hdr is replaced by <space><index into filename
1045 element>. Index is the P.R. of an int (decimal). Data General have
1046 extended the format by using the prefix // for the special element. */
1048 /* Returns FALSE on error, TRUE otherwise. */
1051 _bfd_slurp_extended_name_table (bfd *abfd)
1054 struct areltdata *namedata;
1057 /* FIXME: Formatting sucks here, and in case of failure of BFD_READ,
1058 we probably don't want to return TRUE. */
1059 bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET);
1060 if (bfd_bread (nextname, 16, abfd) == 16)
1062 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1065 if (strncmp (nextname, "ARFILENAMES/ ", 16) != 0 &&
1066 strncmp (nextname, "// ", 16) != 0)
1068 bfd_ardata (abfd)->extended_names = NULL;
1072 namedata = _bfd_read_ar_hdr (abfd);
1073 if (namedata == NULL)
1076 amt = namedata->parsed_size;
1077 bfd_ardata (abfd)->extended_names = bfd_zalloc (abfd, amt);
1078 if (bfd_ardata (abfd)->extended_names == NULL)
1081 bfd_release (abfd, namedata);
1085 if (bfd_bread (bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
1087 if (bfd_get_error () != bfd_error_system_call)
1088 bfd_set_error (bfd_error_malformed_archive);
1089 bfd_release (abfd, (bfd_ardata (abfd)->extended_names));
1090 bfd_ardata (abfd)->extended_names = NULL;
1094 /* Since the archive is supposed to be printable if it contains
1095 text, the entries in the list are newline-padded, not null
1096 padded. In SVR4-style archives, the names also have a
1097 trailing '/'. DOS/NT created archive often have \ in them
1098 We'll fix all problems here.. */
1100 char *temp = bfd_ardata (abfd)->extended_names;
1101 char *limit = temp + namedata->parsed_size;
1102 for (; temp < limit; ++temp)
1104 if (*temp == '\012')
1105 temp[temp[-1] == '/' ? -1 : 0] = '\0';
1111 /* Pad to an even boundary if you have to. */
1112 bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd);
1113 bfd_ardata (abfd)->first_file_filepos +=
1114 (bfd_ardata (abfd)->first_file_filepos) % 2;
1116 /* FIXME, we can't release namedata here because it was allocated
1117 below extended_names on the objalloc... */
1124 /* Return a copy of the stuff in the filename between any :]> and a
1128 normalize (bfd *abfd, const char *file)
1134 first = file + strlen (file) - 1;
1137 while (first != file)
1141 if (*first == ':' || *first == ']' || *first == '>')
1149 copy = bfd_alloc (abfd, last - first + 1);
1153 memcpy (copy, first, last - first);
1154 copy[last - first] = 0;
1161 normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file)
1163 const char *filename = strrchr (file, '/');
1165 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1167 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */
1168 char *bslash = strrchr (file, '\\');
1169 if (filename == NULL || (bslash != NULL && bslash > filename))
1171 if (filename == NULL && file[0] != '\0' && file[1] == ':')
1172 filename = file + 1;
1175 if (filename != NULL)
1183 /* Build a BFD style extended name table. */
1186 _bfd_archive_bsd_construct_extended_name_table (bfd *abfd,
1188 bfd_size_type *tablen,
1191 *name = "ARFILENAMES/";
1192 return _bfd_construct_extended_name_table (abfd, FALSE, tabloc, tablen);
1195 /* Build an SVR4 style extended name table. */
1198 _bfd_archive_coff_construct_extended_name_table (bfd *abfd,
1200 bfd_size_type *tablen,
1204 return _bfd_construct_extended_name_table (abfd, TRUE, tabloc, tablen);
1207 /* Follows archive_head and produces an extended name table if
1208 necessary. Returns (in tabloc) a pointer to an extended name
1209 table, and in tablen the length of the table. If it makes an entry
1210 it clobbers the filename so that the element may be written without
1211 further massage. Returns TRUE if it ran successfully, FALSE if
1212 something went wrong. A successful return may still involve a
1213 zero-length tablen! */
1216 _bfd_construct_extended_name_table (bfd *abfd,
1217 bfd_boolean trailing_slash,
1219 bfd_size_type *tablen)
1221 unsigned int maxname = abfd->xvec->ar_max_namelen;
1222 bfd_size_type total_namelen = 0;
1228 /* Figure out how long the table should be. */
1229 for (current = abfd->archive_head; current != NULL; current = current->next)
1232 unsigned int thislen;
1234 normal = normalize (current, current->filename);
1238 thislen = strlen (normal);
1240 if (thislen > maxname
1241 && (bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1244 if (thislen > maxname)
1246 /* Add one to leave room for \n. */
1247 total_namelen += thislen + 1;
1250 /* Leave room for trailing slash. */
1256 struct ar_hdr *hdr = arch_hdr (current);
1257 if (strncmp (normal, hdr->ar_name, thislen) != 0
1258 || (thislen < sizeof hdr->ar_name
1259 && hdr->ar_name[thislen] != ar_padchar (current)))
1261 /* Must have been using extended format even though it
1262 didn't need to. Fix it to use normal format. */
1263 memcpy (hdr->ar_name, normal, thislen);
1264 if (thislen < maxname
1265 || (thislen == maxname && thislen < sizeof hdr->ar_name))
1266 hdr->ar_name[thislen] = ar_padchar (current);
1271 if (total_namelen == 0)
1274 *tabloc = bfd_zalloc (abfd, total_namelen);
1275 if (*tabloc == NULL)
1278 *tablen = total_namelen;
1281 for (current = abfd->archive_head; current != NULL; current =
1285 unsigned int thislen;
1287 normal = normalize (current, current->filename);
1291 thislen = strlen (normal);
1292 if (thislen > maxname)
1294 /* Works for now; may need to be re-engineered if we
1295 encounter an oddball archive format and want to
1296 generalise this hack. */
1297 struct ar_hdr *hdr = arch_hdr (current);
1298 strcpy (strptr, normal);
1299 if (! trailing_slash)
1300 strptr[thislen] = '\012';
1303 strptr[thislen] = '/';
1304 strptr[thislen + 1] = '\012';
1306 hdr->ar_name[0] = ar_padchar (current);
1307 _bfd_ar_spacepad (hdr->ar_name + 1, maxname - 1, "%-ld",
1309 strptr += thislen + 1;
1318 /* A couple of functions for creating ar_hdrs. */
1320 #ifdef HPUX_LARGE_AR_IDS
1321 /* Function to encode large UID/GID values according to HP. */
1324 hpux_uid_gid_encode (char str[6], long int id)
1328 str[5] = '@' + (id & 3);
1331 for (cnt = 4; cnt >= 0; ++cnt, id >>= 6)
1332 str[cnt] = ' ' + (id & 0x3f);
1334 #endif /* HPUX_LARGE_AR_IDS */
1344 /* Takes a filename, returns an arelt_data for it, or NULL if it can't
1345 make one. The filename must refer to a filename in the filesystem.
1346 The filename field of the ar_hdr will NOT be initialized. If member
1347 is set, and it's an in-memory bfd, we fake it. */
1349 static struct areltdata *
1350 bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
1353 struct areltdata *ared;
1357 if (member && (member->flags & BFD_IN_MEMORY) != 0)
1359 /* Assume we just "made" the member, and fake it. */
1360 struct bfd_in_memory *bim = member->iostream;
1361 time (&status.st_mtime);
1362 status.st_uid = getuid ();
1363 status.st_gid = getgid ();
1364 status.st_mode = 0644;
1365 status.st_size = bim->size;
1367 else if (stat (filename, &status) != 0)
1369 bfd_set_error (bfd_error_system_call);
1373 amt = sizeof (struct ar_hdr) + sizeof (struct areltdata);
1374 ared = bfd_zalloc (abfd, amt);
1377 hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));
1379 /* ar headers are space padded, not null padded! */
1380 memset (hdr, ' ', sizeof (struct ar_hdr));
1382 _bfd_ar_spacepad (hdr->ar_date, sizeof (hdr->ar_date), "%-12ld",
1384 #ifdef HPUX_LARGE_AR_IDS
1385 /* HP has a very "special" way to handle UID/GID's with numeric values
1387 if (status.st_uid > 99999)
1388 hpux_uid_gid_encode (hdr->ar_uid, (long) status.st_uid);
1391 _bfd_ar_spacepad (hdr->ar_uid, sizeof (hdr->ar_uid), "%ld",
1393 #ifdef HPUX_LARGE_AR_IDS
1394 /* HP has a very "special" way to handle UID/GID's with numeric values
1396 if (status.st_gid > 99999)
1397 hpux_uid_gid_encode (hdr->ar_gid, (long) status.st_gid);
1400 _bfd_ar_spacepad (hdr->ar_gid, sizeof (hdr->ar_gid), "%ld",
1402 _bfd_ar_spacepad (hdr->ar_mode, sizeof (hdr->ar_mode), "%-8lo",
1404 _bfd_ar_spacepad (hdr->ar_size, sizeof (hdr->ar_size), "%-10ld",
1406 memcpy (hdr->ar_fmag, ARFMAG, 2);
1407 ared->parsed_size = status.st_size;
1408 ared->arch_header = (char *) hdr;
1413 /* This is magic required by the "ar" program. Since it's
1414 undocumented, it's undocumented. You may think that it would take
1415 a strong stomach to write this, and it does, but it takes even a
1416 stronger stomach to try to code around such a thing! */
1418 struct ar_hdr *bfd_special_undocumented_glue (bfd *, const char *);
1421 bfd_special_undocumented_glue (bfd *abfd, const char *filename)
1423 struct areltdata *ar_elt = bfd_ar_hdr_from_filesystem (abfd, filename, 0);
1426 return (struct ar_hdr *) ar_elt->arch_header;
1429 /* Analogous to stat call. */
1432 bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
1437 if (abfd->arelt_data == NULL)
1439 bfd_set_error (bfd_error_invalid_operation);
1443 hdr = arch_hdr (abfd);
1445 #define foo(arelt, stelt, size) \
1446 buf->stelt = strtol (hdr->arelt, &aloser, size); \
1447 if (aloser == hdr->arelt) \
1450 /* Some platforms support special notations for large IDs. */
1451 #ifdef HPUX_LARGE_AR_IDS
1452 # define foo2(arelt, stelt, size) \
1453 if (hdr->arelt[5] == ' ') \
1455 foo (arelt, stelt, size); \
1460 for (buf->stelt = cnt = 0; cnt < 5; ++cnt) \
1462 if (hdr->arelt[cnt] < ' ' || hdr->arelt[cnt] > ' ' + 0x3f) \
1465 buf->stelt += hdr->arelt[cnt] - ' '; \
1467 if (hdr->arelt[5] < '@' || hdr->arelt[5] > '@' + 3) \
1470 buf->stelt += hdr->arelt[5] - '@'; \
1473 # define foo2(arelt, stelt, size) foo (arelt, stelt, size)
1476 foo (ar_date, st_mtime, 10);
1477 foo2 (ar_uid, st_uid, 10);
1478 foo2 (ar_gid, st_gid, 10);
1479 foo (ar_mode, st_mode, 8);
1481 buf->st_size = arch_eltdata (abfd)->parsed_size;
1487 bfd_dont_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1489 /* FIXME: This interacts unpleasantly with ar's quick-append option.
1490 Fortunately ic960 users will never use that option. Fixing this
1491 is very hard; fortunately I know how to do it and will do so once
1492 intel's release is out the door. */
1494 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1496 const char *filename;
1497 size_t maxlen = ar_maxnamelen (abfd);
1499 if ((bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1501 bfd_bsd_truncate_arname (abfd, pathname, arhdr);
1505 filename = normalize (abfd, pathname);
1506 if (filename == NULL)
1512 length = strlen (filename);
1514 if (length <= maxlen)
1515 memcpy (hdr->ar_name, filename, length);
1517 /* Add the padding character if there is room for it. */
1519 || (length == maxlen && length < sizeof hdr->ar_name))
1520 (hdr->ar_name)[length] = ar_padchar (abfd);
1524 bfd_bsd_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1526 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1528 const char *filename = strrchr (pathname, '/');
1529 size_t maxlen = ar_maxnamelen (abfd);
1531 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1533 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */
1534 char *bslash = strrchr (pathname, '\\');
1535 if (filename == NULL || (bslash != NULL && bslash > filename))
1537 if (filename == NULL && pathname[0] != '\0' && pathname[1] == ':')
1538 filename = pathname + 1;
1542 if (filename == NULL)
1543 filename = pathname;
1547 length = strlen (filename);
1549 if (length <= maxlen)
1550 memcpy (hdr->ar_name, filename, length);
1553 /* pathname: meet procrustes */
1554 memcpy (hdr->ar_name, filename, maxlen);
1558 if (length < maxlen)
1559 (hdr->ar_name)[length] = ar_padchar (abfd);
1562 /* Store name into ar header. Truncates the name to fit.
1563 1> strip pathname to be just the basename.
1564 2> if it's short enuf to fit, stuff it in.
1565 3> If it doesn't end with .o, truncate it to fit
1566 4> truncate it before the .o, append .o, stuff THAT in. */
1568 /* This is what gnu ar does. It's better but incompatible with the
1572 bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1574 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1576 const char *filename = strrchr (pathname, '/');
1577 size_t maxlen = ar_maxnamelen (abfd);
1579 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1581 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */
1582 char *bslash = strrchr (pathname, '\\');
1583 if (filename == NULL || (bslash != NULL && bslash > filename))
1585 if (filename == NULL && pathname[0] != '\0' && pathname[1] == ':')
1586 filename = pathname + 1;
1590 if (filename == NULL)
1591 filename = pathname;
1595 length = strlen (filename);
1597 if (length <= maxlen)
1598 memcpy (hdr->ar_name, filename, length);
1600 { /* pathname: meet procrustes */
1601 memcpy (hdr->ar_name, filename, maxlen);
1602 if ((filename[length - 2] == '.') && (filename[length - 1] == 'o'))
1604 hdr->ar_name[maxlen - 2] = '.';
1605 hdr->ar_name[maxlen - 1] = 'o';
1611 (hdr->ar_name)[length] = ar_padchar (abfd);
1614 /* The BFD is open for write and has its format set to bfd_archive. */
1617 _bfd_write_archive_contents (bfd *arch)
1620 char *etable = NULL;
1621 bfd_size_type elength = 0;
1622 const char *ename = NULL;
1623 bfd_boolean makemap = bfd_has_map (arch);
1624 /* If no .o's, don't bother to make a map. */
1625 bfd_boolean hasobjects = FALSE;
1626 bfd_size_type wrote;
1629 /* Verify the viability of all entries; if any of them live in the
1630 filesystem (as opposed to living in an archive open for input)
1631 then construct a fresh ar_hdr for them. */
1632 for (current = arch->archive_head; current; current = current->next)
1634 /* This check is checking the bfds for the objects we're reading
1635 from (which are usually either an object file or archive on
1636 disk), not the archive entries we're writing to. We don't
1637 actually create bfds for the archive members, we just copy
1638 them byte-wise when we write out the archive. */
1639 if (bfd_write_p (current))
1641 bfd_set_error (bfd_error_invalid_operation);
1644 if (!current->arelt_data)
1646 current->arelt_data =
1647 bfd_ar_hdr_from_filesystem (arch, current->filename, current);
1648 if (!current->arelt_data)
1651 /* Put in the file name. */
1652 BFD_SEND (arch, _bfd_truncate_arname,
1653 (arch, current->filename, (char *) arch_hdr (current)));
1656 if (makemap && ! hasobjects)
1657 { /* Don't bother if we won't make a map! */
1658 if ((bfd_check_format (current, bfd_object)))
1663 if (!BFD_SEND (arch, _bfd_construct_extended_name_table,
1664 (arch, &etable, &elength, &ename)))
1667 if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0)
1669 wrote = bfd_bwrite (ARMAG, SARMAG, arch);
1670 if (wrote != SARMAG)
1673 if (makemap && hasobjects)
1675 if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength))
1683 memset (&hdr, ' ', sizeof (struct ar_hdr));
1684 memcpy (hdr.ar_name, ename, strlen (ename));
1685 /* Round size up to even number in archive header. */
1686 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld",
1687 (elength + 1) & ~(bfd_size_type) 1);
1688 memcpy (hdr.ar_fmag, ARFMAG, 2);
1689 if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
1690 != sizeof (struct ar_hdr))
1691 || bfd_bwrite (etable, elength, arch) != elength)
1693 if ((elength % 2) == 1)
1695 if (bfd_bwrite ("\012", 1, arch) != 1)
1700 for (current = arch->archive_head; current; current = current->next)
1702 char buffer[DEFAULT_BUFFERSIZE];
1703 unsigned int remaining = arelt_size (current);
1704 struct ar_hdr *hdr = arch_hdr (current);
1706 /* Write ar header. */
1707 if (bfd_bwrite (hdr, sizeof (*hdr), arch)
1710 if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
1714 unsigned int amt = DEFAULT_BUFFERSIZE;
1715 if (amt > remaining)
1718 if (bfd_bread (buffer, amt, current) != amt)
1720 if (bfd_get_error () != bfd_error_system_call)
1721 bfd_set_error (bfd_error_malformed_archive);
1724 if (bfd_bwrite (buffer, amt, arch) != amt)
1728 if ((arelt_size (current) % 2) == 1)
1730 if (bfd_bwrite ("\012", 1, arch) != 1)
1735 if (makemap && hasobjects)
1737 /* Verify the timestamp in the archive file. If it would not be
1738 accepted by the linker, rewrite it until it would be. If
1739 anything odd happens, break out and just return. (The
1740 Berkeley linker checks the timestamp and refuses to read the
1741 table-of-contents if it is >60 seconds less than the file's
1742 modified-time. That painful hack requires this painful hack. */
1746 if (bfd_update_armap_timestamp (arch))
1748 (*_bfd_error_handler)
1749 (_("Warning: writing archive was slow: rewriting timestamp\n"));
1751 while (++tries < 6);
1757 /* Note that the namidx for the first symbol is 0. */
1760 _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
1762 char *first_name = NULL;
1764 file_ptr elt_no = 0;
1765 struct orl *map = NULL;
1766 unsigned int orl_max = 1024; /* Fine initial default. */
1767 unsigned int orl_count = 0;
1769 asymbol **syms = NULL;
1774 /* Dunno if this is the best place for this info... */
1776 elength += sizeof (struct ar_hdr);
1777 elength += elength % 2;
1779 amt = orl_max * sizeof (struct orl);
1780 map = bfd_malloc (amt);
1784 /* We put the symbol names on the arch objalloc, and then discard
1786 first_name = bfd_alloc (arch, 1);
1787 if (first_name == NULL)
1790 /* Drop all the files called __.SYMDEF, we're going to make our own. */
1791 while (arch->archive_head &&
1792 strcmp (arch->archive_head->filename, "__.SYMDEF") == 0)
1793 arch->archive_head = arch->archive_head->next;
1795 /* Map over each element. */
1796 for (current = arch->archive_head;
1798 current = current->next, elt_no++)
1800 if (bfd_check_format (current, bfd_object)
1801 && (bfd_get_file_flags (current) & HAS_SYMS) != 0)
1807 storage = bfd_get_symtab_upper_bound (current);
1813 if (storage > syms_max)
1818 syms = bfd_malloc (syms_max);
1822 symcount = bfd_canonicalize_symtab (current, syms);
1826 /* Now map over all the symbols, picking out the ones we
1828 for (src_count = 0; src_count < symcount; src_count++)
1830 flagword flags = (syms[src_count])->flags;
1831 asection *sec = syms[src_count]->section;
1833 if ((flags & BSF_GLOBAL ||
1835 flags & BSF_INDIRECT ||
1836 bfd_is_com_section (sec))
1837 && ! bfd_is_und_section (sec))
1839 bfd_size_type namelen;
1840 struct orl *new_map;
1842 /* This symbol will go into the archive header. */
1843 if (orl_count == orl_max)
1846 amt = orl_max * sizeof (struct orl);
1847 new_map = bfd_realloc (map, amt);
1848 if (new_map == NULL)
1854 namelen = strlen (syms[src_count]->name);
1855 amt = sizeof (char *);
1856 map[orl_count].name = bfd_alloc (arch, amt);
1857 if (map[orl_count].name == NULL)
1859 *(map[orl_count].name) = bfd_alloc (arch, namelen + 1);
1860 if (*(map[orl_count].name) == NULL)
1862 strcpy (*(map[orl_count].name), syms[src_count]->name);
1863 map[orl_count].u.abfd = current;
1864 map[orl_count].namidx = stridx;
1866 stridx += namelen + 1;
1872 /* Now ask the BFD to free up any cached information, so we
1873 don't fill all of memory with symbol tables. */
1874 if (! bfd_free_cached_info (current))
1879 /* OK, now we have collected all the data, let's write them out. */
1880 ret = BFD_SEND (arch, write_armap,
1881 (arch, elength, map, orl_count, stridx));
1887 if (first_name != NULL)
1888 bfd_release (arch, first_name);
1897 if (first_name != NULL)
1898 bfd_release (arch, first_name);
1904 bsd_write_armap (bfd *arch,
1905 unsigned int elength,
1907 unsigned int orl_count,
1910 int padit = stridx & 1;
1911 unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE;
1912 unsigned int stringsize = stridx + padit;
1913 /* Include 8 bytes to store ranlibsize and stringsize in output. */
1914 unsigned int mapsize = ranlibsize + stringsize + 8;
1916 bfd *current = arch->archive_head;
1917 bfd *last_elt = current; /* Last element arch seen. */
1921 struct stat statbuf;
1923 firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
1925 stat (arch->filename, &statbuf);
1926 memset (&hdr, ' ', sizeof (struct ar_hdr));
1927 memcpy (hdr.ar_name, RANLIBMAG, strlen (RANLIBMAG));
1928 /* Remember the timestamp, to keep it holy. But fudge it a little. */
1929 bfd_ardata (arch)->armap_timestamp = statbuf.st_mtime + ARMAP_TIME_OFFSET;
1930 bfd_ardata (arch)->armap_datepos = (SARMAG
1931 + offsetof (struct ar_hdr, ar_date[0]));
1932 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
1933 bfd_ardata (arch)->armap_timestamp);
1934 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", getuid ());
1935 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", getgid ());
1936 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld", mapsize);
1937 memcpy (hdr.ar_fmag, ARFMAG, 2);
1938 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
1939 != sizeof (struct ar_hdr))
1941 H_PUT_32 (arch, ranlibsize, temp);
1942 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
1945 for (count = 0; count < orl_count; count++)
1947 bfd_byte buf[BSD_SYMDEF_SIZE];
1949 if (map[count].u.abfd != last_elt)
1953 firstreal += arelt_size (current) + sizeof (struct ar_hdr);
1954 firstreal += firstreal % 2;
1955 current = current->next;
1957 while (current != map[count].u.abfd);
1961 H_PUT_32 (arch, map[count].namidx, buf);
1962 H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE);
1963 if (bfd_bwrite (buf, BSD_SYMDEF_SIZE, arch)
1968 /* Now write the strings themselves. */
1969 H_PUT_32 (arch, stringsize, temp);
1970 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
1972 for (count = 0; count < orl_count; count++)
1974 size_t len = strlen (*map[count].name) + 1;
1976 if (bfd_bwrite (*map[count].name, len, arch) != len)
1980 /* The spec sez this should be a newline. But in order to be
1981 bug-compatible for sun's ar we use a null. */
1984 if (bfd_bwrite ("", 1, arch) != 1)
1991 /* At the end of archive file handling, update the timestamp in the
1992 file, so the linker will accept it.
1994 Return TRUE if the timestamp was OK, or an unusual problem happened.
1995 Return FALSE if we updated the timestamp. */
1998 _bfd_archive_bsd_update_armap_timestamp (bfd *arch)
2000 struct stat archstat;
2003 /* Flush writes, get last-write timestamp from file, and compare it
2004 to the timestamp IN the file. */
2006 if (bfd_stat (arch, &archstat) == -1)
2008 bfd_perror (_("Reading archive file mod timestamp"));
2010 /* Can't read mod time for some reason. */
2013 if (archstat.st_mtime <= bfd_ardata (arch)->armap_timestamp)
2014 /* OK by the linker's rules. */
2017 /* Update the timestamp. */
2018 bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET;
2020 /* Prepare an ASCII version suitable for writing. */
2021 memset (hdr.ar_date, ' ', sizeof (hdr.ar_date));
2022 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2023 bfd_ardata (arch)->armap_timestamp);
2025 /* Write it into the file. */
2026 bfd_ardata (arch)->armap_datepos = (SARMAG
2027 + offsetof (struct ar_hdr, ar_date[0]));
2028 if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0
2029 || (bfd_bwrite (hdr.ar_date, sizeof (hdr.ar_date), arch)
2030 != sizeof (hdr.ar_date)))
2032 bfd_perror (_("Writing updated armap timestamp"));
2034 /* Some error while writing. */
2038 /* We updated the timestamp successfully. */
2042 /* A coff armap looks like :
2044 struct ar_hdr with name = '/'
2046 offset of file for symbol 0
2047 offset of file for symbol 1
2049 offset of file for symbol n-1
2056 coff_write_armap (bfd *arch,
2057 unsigned int elength,
2059 unsigned int symbol_count,
2062 /* The size of the ranlib is the number of exported symbols in the
2063 archive * the number of bytes in an int, + an int for the count. */
2064 unsigned int ranlibsize = (symbol_count * 4) + 4;
2065 unsigned int stringsize = stridx;
2066 unsigned int mapsize = stringsize + ranlibsize;
2067 unsigned int archive_member_file_ptr;
2068 bfd *current = arch->archive_head;
2071 int padit = mapsize & 1;
2076 /* Work out where the first object file will go in the archive. */
2077 archive_member_file_ptr = (mapsize
2079 + sizeof (struct ar_hdr)
2082 memset (&hdr, ' ', sizeof (struct ar_hdr));
2083 hdr.ar_name[0] = '/';
2084 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld",
2086 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2088 /* This, at least, is what Intel coff sets the values to. */
2089 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", 0);
2090 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", 0);
2091 _bfd_ar_spacepad (hdr.ar_mode, sizeof (hdr.ar_mode), "%-7lo", 0);
2092 memcpy (hdr.ar_fmag, ARFMAG, 2);
2094 /* Write the ar header for this item and the number of symbols. */
2095 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2096 != sizeof (struct ar_hdr))
2099 if (!bfd_write_bigendian_4byte_int (arch, symbol_count))
2102 /* Two passes, first write the file offsets for each symbol -
2103 remembering that each offset is on a two byte boundary. */
2105 /* Write out the file offset for the file associated with each
2106 symbol, and remember to keep the offsets padded out. */
2108 current = arch->archive_head;
2110 while (current != NULL && count < symbol_count)
2112 /* For each symbol which is used defined in this object, write
2113 out the object file's address in the archive. */
2115 while (count < symbol_count && map[count].u.abfd == current)
2117 if (!bfd_write_bigendian_4byte_int (arch, archive_member_file_ptr))
2121 /* Add size of this archive entry. */
2122 archive_member_file_ptr += arelt_size (current) + sizeof (struct ar_hdr);
2123 /* Remember aboout the even alignment. */
2124 archive_member_file_ptr += archive_member_file_ptr % 2;
2125 current = current->next;
2128 /* Now write the strings themselves. */
2129 for (count = 0; count < symbol_count; count++)
2131 size_t len = strlen (*map[count].name) + 1;
2133 if (bfd_bwrite (*map[count].name, len, arch) != len)
2137 /* The spec sez this should be a newline. But in order to be
2138 bug-compatible for arc960 we use a null. */
2141 if (bfd_bwrite ("", 1, arch) != 1)