daily update
[binutils.git] / bfd / archive.c
blob437a0859eaccbb01583382925420e9b737b17d86
1 /* BFD back-end for archive files (libraries).
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
5 Written by Cygnus Support. Mostly Gumby Henkel-Wallace's fault.
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
25 SECTION
26 Archives
28 DESCRIPTION
29 An archive (or library) is just another BFD. It has a symbol
30 table, although there's not much a user program will do with it.
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
66 homogeneous.
68 Beware: most of these formats do not react well to the
69 presence of spaces in filenames. We do the best we can, but
70 can't always handle this case due to restrictions in the format of
71 archives. Many Unix utilities are braindead in regards to
72 spaces and such in filenames anyway, so this shouldn't be much
73 of a restriction.
75 Archives are supported in BFD in <<archive.c>>.
77 SUBSECTION
78 Archive functions
81 /* Assumes:
82 o - all archive elements start on an even boundary, newline padded;
83 o - all arch headers are char *;
84 o - all arch headers are the same size (across architectures).
87 /* Some formats provide a way to cram a long filename into the short
88 (16 chars) space provided by a BSD archive. The trick is: make a
89 special "file" in the front of the archive, sort of like the SYMDEF
90 entry. If the filename is too long to fit, put it in the extended
91 name table, and use its index as the filename. To prevent
92 confusion prepend the index with a space. This means you can't
93 have filenames that start with a space, but then again, many Unix
94 utilities can't handle that anyway.
96 This scheme unfortunately requires that you stand on your head in
97 order to write an archive since you need to put a magic file at the
98 front, and need to touch every entry to do so. C'est la vie.
100 We support two variants of this idea:
101 The SVR4 format (extended name table is named "//"),
102 and an extended pseudo-BSD variant (extended name table is named
103 "ARFILENAMES/"). The origin of the latter format is uncertain.
105 BSD 4.4 uses a third scheme: It writes a long filename
106 directly after the header. This allows 'ar q' to work.
107 We currently can read BSD 4.4 archives, but not write them.
110 /* Summary of archive member names:
112 Symbol table (must be first):
113 "__.SYMDEF " - Symbol table, Berkeley style, produced by ranlib.
114 "/ " - Symbol table, system 5 style.
116 Long name table (must be before regular file members):
117 "// " - Long name table, System 5 R4 style.
118 "ARFILENAMES/ " - Long name table, non-standard extended BSD (not BSD 4.4).
120 Regular file members with short names:
121 "filename.o/ " - Regular file, System 5 style (embedded spaces ok).
122 "filename.o " - Regular file, Berkeley style (no embedded spaces).
124 Regular files with long names (or embedded spaces, for BSD variants):
125 "/18 " - SVR4 style, name at offset 18 in name table.
126 "#1/23 " - Long name (or embedded spaces) 23 characters long,
127 BSD 4.4 style, full name follows header.
128 Implemented for reading, not writing.
129 " 18 " - Long name 18 characters long, extended pseudo-BSD.
132 #include "sysdep.h"
133 #include "bfd.h"
134 #include "libiberty.h"
135 #include "libbfd.h"
136 #include "aout/ar.h"
137 #include "aout/ranlib.h"
138 #include "safe-ctype.h"
139 #include "hashtab.h"
140 #include "filenames.h"
142 #ifndef errno
143 extern int errno;
144 #endif
146 /* We keep a cache of archive filepointers to archive elements to
147 speed up searching the archive by filepos. We only add an entry to
148 the cache when we actually read one. We also don't sort the cache;
149 it's generally short enough to search linearly.
150 Note that the pointers here point to the front of the ar_hdr, not
151 to the front of the contents! */
152 struct ar_cache {
153 file_ptr ptr;
154 bfd *arbfd;
157 #define ar_padchar(abfd) ((abfd)->xvec->ar_pad_char)
158 #define ar_maxnamelen(abfd) ((abfd)->xvec->ar_max_namelen)
160 #define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data))
161 #define arch_hdr(bfd) ((struct ar_hdr *) arch_eltdata (bfd)->arch_header)
163 void
164 _bfd_ar_spacepad (char *p, size_t n, const char *fmt, long val)
166 static char buf[20];
167 size_t len;
168 snprintf (buf, sizeof (buf), fmt, val);
169 len = strlen (buf);
170 if (len < n)
172 memcpy (p, buf, len);
173 memset (p + len, ' ', n - len);
175 else
176 memcpy (p, buf, n);
179 bfd_boolean
180 _bfd_generic_mkarchive (bfd *abfd)
182 bfd_size_type amt = sizeof (struct artdata);
184 abfd->tdata.aout_ar_data = bfd_zalloc (abfd, amt);
185 if (bfd_ardata (abfd) == NULL)
186 return FALSE;
188 /* Already cleared by bfd_zalloc above.
189 bfd_ardata (abfd)->cache = NULL;
190 bfd_ardata (abfd)->archive_head = NULL;
191 bfd_ardata (abfd)->symdefs = NULL;
192 bfd_ardata (abfd)->extended_names = NULL;
193 bfd_ardata (abfd)->extended_names_size = 0;
194 bfd_ardata (abfd)->tdata = NULL; */
196 return TRUE;
200 FUNCTION
201 bfd_get_next_mapent
203 SYNOPSIS
204 symindex bfd_get_next_mapent
205 (bfd *abfd, symindex previous, carsym **sym);
207 DESCRIPTION
208 Step through archive @var{abfd}'s symbol table (if it
209 has one). Successively update @var{sym} with the next symbol's
210 information, returning that symbol's (internal) index into the
211 symbol table.
213 Supply <<BFD_NO_MORE_SYMBOLS>> as the @var{previous} entry to get
214 the first one; returns <<BFD_NO_MORE_SYMBOLS>> when you've already
215 got the last one.
217 A <<carsym>> is a canonical archive symbol. The only
218 user-visible element is its name, a null-terminated string.
221 symindex
222 bfd_get_next_mapent (bfd *abfd, symindex prev, carsym **entry)
224 if (!bfd_has_map (abfd))
226 bfd_set_error (bfd_error_invalid_operation);
227 return BFD_NO_MORE_SYMBOLS;
230 if (prev == BFD_NO_MORE_SYMBOLS)
231 prev = 0;
232 else
233 ++prev;
234 if (prev >= bfd_ardata (abfd)->symdef_count)
235 return BFD_NO_MORE_SYMBOLS;
237 *entry = (bfd_ardata (abfd)->symdefs + prev);
238 return prev;
241 /* To be called by backends only. */
243 bfd *
244 _bfd_create_empty_archive_element_shell (bfd *obfd)
246 return _bfd_new_bfd_contained_in (obfd);
250 FUNCTION
251 bfd_set_archive_head
253 SYNOPSIS
254 bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);
256 DESCRIPTION
257 Set the head of the chain of
258 BFDs contained in the archive @var{output} to @var{new_head}.
261 bfd_boolean
262 bfd_set_archive_head (bfd *output_archive, bfd *new_head)
264 output_archive->archive_head = new_head;
265 return TRUE;
268 bfd *
269 _bfd_look_for_bfd_in_cache (bfd *arch_bfd, file_ptr filepos)
271 htab_t hash_table = bfd_ardata (arch_bfd)->cache;
272 struct ar_cache m;
273 m.ptr = filepos;
275 if (hash_table)
277 struct ar_cache *entry = (struct ar_cache *) htab_find (hash_table, &m);
278 if (!entry)
279 return NULL;
280 else
281 return entry->arbfd;
283 else
284 return NULL;
287 static hashval_t
288 hash_file_ptr (const PTR p)
290 return (hashval_t) (((struct ar_cache *) p)->ptr);
293 /* Returns non-zero if P1 and P2 are equal. */
295 static int
296 eq_file_ptr (const PTR p1, const PTR p2)
298 struct ar_cache *arc1 = (struct ar_cache *) p1;
299 struct ar_cache *arc2 = (struct ar_cache *) p2;
300 return arc1->ptr == arc2->ptr;
303 /* Kind of stupid to call cons for each one, but we don't do too many. */
305 bfd_boolean
306 _bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt)
308 struct ar_cache *cache;
309 htab_t hash_table = bfd_ardata (arch_bfd)->cache;
311 /* If the hash table hasn't been created, create it. */
312 if (hash_table == NULL)
314 hash_table = htab_create_alloc (16, hash_file_ptr, eq_file_ptr,
315 NULL, calloc, free);
316 if (hash_table == NULL)
317 return FALSE;
318 bfd_ardata (arch_bfd)->cache = hash_table;
321 /* Insert new_elt into the hash table by filepos. */
322 cache = bfd_zalloc (arch_bfd, sizeof (struct ar_cache));
323 cache->ptr = filepos;
324 cache->arbfd = new_elt;
325 *htab_find_slot (hash_table, (const void *) cache, INSERT) = cache;
327 return TRUE;
330 static bfd *
331 _bfd_find_nested_archive (bfd *arch_bfd, const char *filename)
333 bfd *abfd;
335 for (abfd = arch_bfd->nested_archives;
336 abfd != NULL;
337 abfd = abfd->archive_next)
339 if (strcmp (filename, abfd->filename) == 0)
340 return abfd;
342 abfd = bfd_openr (filename, NULL);
343 if (abfd)
345 abfd->archive_next = arch_bfd->nested_archives;
346 arch_bfd->nested_archives = abfd;
348 return abfd;
351 /* The name begins with space. Hence the rest of the name is an index into
352 the string table. */
354 static char *
355 get_extended_arelt_filename (bfd *arch, const char *name, file_ptr *originp)
357 unsigned long index = 0;
358 const char *endp;
360 /* Should extract string so that I can guarantee not to overflow into
361 the next region, but I'm too lazy. */
362 errno = 0;
363 /* Skip first char, which is '/' in SVR4 or ' ' in some other variants. */
364 index = strtol (name + 1, (char **) &endp, 10);
365 if (errno != 0 || index >= bfd_ardata (arch)->extended_names_size)
367 bfd_set_error (bfd_error_malformed_archive);
368 return NULL;
370 /* In a thin archive, a member of an archive-within-an-archive
371 will have the offset in the inner archive encoded here. */
372 if (bfd_is_thin_archive (arch) && endp != NULL && *endp == ':')
374 file_ptr origin = strtol (endp + 1, NULL, 10);
376 if (errno != 0 || index >= bfd_ardata (arch)->extended_names_size)
378 bfd_set_error (bfd_error_malformed_archive);
379 return NULL;
381 *originp = origin;
383 else
384 *originp = 0;
386 return bfd_ardata (arch)->extended_names + index;
389 /* This functions reads an arch header and returns an areltdata pointer, or
390 NULL on error.
392 Presumes the file pointer is already in the right place (ie pointing
393 to the ar_hdr in the file). Moves the file pointer; on success it
394 should be pointing to the front of the file contents; on failure it
395 could have been moved arbitrarily. */
397 void *
398 _bfd_generic_read_ar_hdr (bfd *abfd)
400 return _bfd_generic_read_ar_hdr_mag (abfd, NULL);
403 /* Alpha ECOFF uses an optional different ARFMAG value, so we have a
404 variant of _bfd_generic_read_ar_hdr which accepts a magic string. */
406 void *
407 _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
409 struct ar_hdr hdr;
410 char *hdrp = (char *) &hdr;
411 size_t parsed_size;
412 struct areltdata *ared;
413 char *filename = NULL;
414 bfd_size_type namelen = 0;
415 bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
416 char *allocptr = 0;
417 file_ptr origin = 0;
419 if (bfd_bread (hdrp, sizeof (struct ar_hdr), abfd) != sizeof (struct ar_hdr))
421 if (bfd_get_error () != bfd_error_system_call)
422 bfd_set_error (bfd_error_no_more_archived_files);
423 return NULL;
425 if (strncmp (hdr.ar_fmag, ARFMAG, 2) != 0
426 && (mag == NULL
427 || strncmp (hdr.ar_fmag, mag, 2) != 0))
429 bfd_set_error (bfd_error_malformed_archive);
430 return NULL;
433 errno = 0;
434 parsed_size = strtol (hdr.ar_size, NULL, 10);
435 if (errno != 0)
437 bfd_set_error (bfd_error_malformed_archive);
438 return NULL;
441 /* Extract the filename from the archive - there are two ways to
442 specify an extended name table, either the first char of the
443 name is a space, or it's a slash. */
444 if ((hdr.ar_name[0] == '/'
445 || (hdr.ar_name[0] == ' '
446 && memchr (hdr.ar_name, '/', ar_maxnamelen (abfd)) == NULL))
447 && bfd_ardata (abfd)->extended_names != NULL)
449 filename = get_extended_arelt_filename (abfd, hdr.ar_name, &origin);
450 if (filename == NULL)
451 return NULL;
453 /* BSD4.4-style long filename.
454 Only implemented for reading, so far! */
455 else if (hdr.ar_name[0] == '#'
456 && hdr.ar_name[1] == '1'
457 && hdr.ar_name[2] == '/'
458 && ISDIGIT (hdr.ar_name[3]))
460 /* BSD-4.4 extended name */
461 namelen = atoi (&hdr.ar_name[3]);
462 allocsize += namelen + 1;
463 parsed_size -= namelen;
465 allocptr = bfd_zalloc (abfd, allocsize);
466 if (allocptr == NULL)
467 return NULL;
468 filename = (allocptr
469 + sizeof (struct areltdata)
470 + sizeof (struct ar_hdr));
471 if (bfd_bread (filename, namelen, abfd) != namelen)
473 if (bfd_get_error () != bfd_error_system_call)
474 bfd_set_error (bfd_error_no_more_archived_files);
475 return NULL;
477 filename[namelen] = '\0';
479 else
481 /* We judge the end of the name by looking for '/' or ' '.
482 Note: The SYSV format (terminated by '/') allows embedded
483 spaces, so only look for ' ' if we don't find '/'. */
485 char *e;
486 e = memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
487 if (e == NULL)
489 e = memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
490 if (e == NULL)
491 e = memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
494 if (e != NULL)
495 namelen = e - hdr.ar_name;
496 else
498 /* If we didn't find a termination character, then the name
499 must be the entire field. */
500 namelen = ar_maxnamelen (abfd);
503 allocsize += namelen + 1;
506 if (!allocptr)
508 allocptr = bfd_zalloc (abfd, allocsize);
509 if (allocptr == NULL)
510 return NULL;
513 ared = (struct areltdata *) allocptr;
515 ared->arch_header = allocptr + sizeof (struct areltdata);
516 memcpy (ared->arch_header, &hdr, sizeof (struct ar_hdr));
517 ared->parsed_size = parsed_size;
518 ared->origin = origin;
520 if (filename != NULL)
521 ared->filename = filename;
522 else
524 ared->filename = allocptr + (sizeof (struct areltdata) +
525 sizeof (struct ar_hdr));
526 if (namelen)
527 memcpy (ared->filename, hdr.ar_name, namelen);
528 ared->filename[namelen] = '\0';
531 return ared;
534 /* Append the relative pathname for a member of the thin archive
535 to the pathname of the directory containing the archive. */
537 static char *
538 append_relative_path (bfd *arch, char *elt_name)
540 const char *arch_name = arch->filename;
541 const char *base_name = lbasename (arch_name);
542 size_t prefix_len;
543 char *filename;
545 if (base_name == arch_name)
546 return elt_name;
548 prefix_len = base_name - arch_name;
549 filename = bfd_alloc (arch, prefix_len + strlen (elt_name) + 1);
550 if (filename == NULL)
551 return NULL;
553 strncpy (filename, arch_name, prefix_len);
554 strcpy (filename + prefix_len, elt_name);
555 return filename;
558 /* This is an internal function; it's mainly used when indexing
559 through the archive symbol table, but also used to get the next
560 element, since it handles the bookkeeping so nicely for us. */
562 bfd *
563 _bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos)
565 struct areltdata *new_areldata;
566 bfd *n_nfd;
567 char *filename;
569 if (archive->my_archive)
571 filepos += archive->origin;
572 archive = archive->my_archive;
575 n_nfd = _bfd_look_for_bfd_in_cache (archive, filepos);
576 if (n_nfd)
577 return n_nfd;
579 if (0 > bfd_seek (archive, filepos, SEEK_SET))
580 return NULL;
582 if ((new_areldata = _bfd_read_ar_hdr (archive)) == NULL)
583 return NULL;
585 filename = new_areldata->filename;
587 if (bfd_is_thin_archive (archive))
589 /* This is a proxy entry for an external file. */
590 if (! IS_ABSOLUTE_PATH (filename))
592 filename = append_relative_path (archive, filename);
593 if (filename == NULL)
594 return NULL;
597 if (new_areldata->origin > 0)
599 /* This proxy entry refers to an element of a nested archive.
600 Locate the member of that archive and return a bfd for it. */
601 bfd *ext_arch = _bfd_find_nested_archive (archive, filename);
603 if (ext_arch == NULL
604 || ! bfd_check_format (ext_arch, bfd_archive))
606 bfd_release (archive, new_areldata);
607 return NULL;
609 n_nfd = _bfd_get_elt_at_filepos (ext_arch, new_areldata->origin);
610 if (n_nfd == NULL)
612 bfd_release (archive, new_areldata);
613 return NULL;
615 n_nfd->proxy_origin = bfd_tell (archive);
616 return n_nfd;
618 /* It's not an element of a nested archive;
619 open the external file as a bfd. */
620 n_nfd = bfd_openr (filename, NULL);
622 else
624 n_nfd = _bfd_create_empty_archive_element_shell (archive);
627 if (n_nfd == NULL)
629 bfd_release (archive, new_areldata);
630 return NULL;
633 n_nfd->proxy_origin = bfd_tell (archive);
635 if (bfd_is_thin_archive (archive))
637 n_nfd->origin = 0;
639 else
641 n_nfd->origin = n_nfd->proxy_origin;
642 n_nfd->filename = filename;
645 n_nfd->arelt_data = new_areldata;
647 if (_bfd_add_bfd_to_archive_cache (archive, filepos, n_nfd))
648 return n_nfd;
650 /* Huh? */
651 /* FIXME: n_nfd isn't allocated in the archive's memory pool.
652 If we reach this point, I think bfd_release will abort. */
653 bfd_release (archive, n_nfd);
654 bfd_release (archive, new_areldata);
655 return NULL;
658 /* Return the BFD which is referenced by the symbol in ABFD indexed by
659 INDEX. INDEX should have been returned by bfd_get_next_mapent. */
661 bfd *
662 _bfd_generic_get_elt_at_index (bfd *abfd, symindex index)
664 carsym *entry;
666 entry = bfd_ardata (abfd)->symdefs + index;
667 return _bfd_get_elt_at_filepos (abfd, entry->file_offset);
671 FUNCTION
672 bfd_openr_next_archived_file
674 SYNOPSIS
675 bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous);
677 DESCRIPTION
678 Provided a BFD, @var{archive}, containing an archive and NULL, open
679 an input BFD on the first contained element and returns that.
680 Subsequent calls should pass
681 the archive and the previous return value to return a created
682 BFD to the next contained element. NULL is returned when there
683 are no more.
686 bfd *
687 bfd_openr_next_archived_file (bfd *archive, bfd *last_file)
689 if ((bfd_get_format (archive) != bfd_archive)
690 || (archive->direction == write_direction))
692 bfd_set_error (bfd_error_invalid_operation);
693 return NULL;
696 return BFD_SEND (archive,
697 openr_next_archived_file, (archive, last_file));
700 bfd *
701 bfd_generic_openr_next_archived_file (bfd *archive, bfd *last_file)
703 file_ptr filestart;
705 if (!last_file)
706 filestart = bfd_ardata (archive)->first_file_filepos;
707 else
709 unsigned int size = arelt_size (last_file);
710 filestart = last_file->proxy_origin;
711 if (! bfd_is_thin_archive (archive))
712 filestart += size;
713 if (archive->my_archive)
714 filestart -= archive->origin;
715 /* Pad to an even boundary...
716 Note that last_file->origin can be odd in the case of
717 BSD-4.4-style element with a long odd size. */
718 filestart += filestart % 2;
721 return _bfd_get_elt_at_filepos (archive, filestart);
724 const bfd_target *
725 bfd_generic_archive_p (bfd *abfd)
727 struct artdata *tdata_hold;
728 char armag[SARMAG + 1];
729 bfd_size_type amt;
731 if (bfd_bread (armag, SARMAG, abfd) != SARMAG)
733 if (bfd_get_error () != bfd_error_system_call)
734 bfd_set_error (bfd_error_wrong_format);
735 return NULL;
738 bfd_is_thin_archive (abfd) = (strncmp (armag, ARMAGT, SARMAG) == 0);
740 if (strncmp (armag, ARMAG, SARMAG) != 0
741 && strncmp (armag, ARMAGB, SARMAG) != 0
742 && ! bfd_is_thin_archive (abfd))
743 return 0;
745 tdata_hold = bfd_ardata (abfd);
747 amt = sizeof (struct artdata);
748 bfd_ardata (abfd) = bfd_zalloc (abfd, amt);
749 if (bfd_ardata (abfd) == NULL)
751 bfd_ardata (abfd) = tdata_hold;
752 return NULL;
755 bfd_ardata (abfd)->first_file_filepos = SARMAG;
756 /* Cleared by bfd_zalloc above.
757 bfd_ardata (abfd)->cache = NULL;
758 bfd_ardata (abfd)->archive_head = NULL;
759 bfd_ardata (abfd)->symdefs = NULL;
760 bfd_ardata (abfd)->extended_names = NULL;
761 bfd_ardata (abfd)->extended_names_size = 0;
762 bfd_ardata (abfd)->tdata = NULL; */
764 if (!BFD_SEND (abfd, _bfd_slurp_armap, (abfd))
765 || !BFD_SEND (abfd, _bfd_slurp_extended_name_table, (abfd)))
767 if (bfd_get_error () != bfd_error_system_call)
768 bfd_set_error (bfd_error_wrong_format);
769 bfd_release (abfd, bfd_ardata (abfd));
770 bfd_ardata (abfd) = tdata_hold;
771 return NULL;
774 if (bfd_has_map (abfd))
776 bfd *first;
778 /* This archive has a map, so we may presume that the contents
779 are object files. Make sure that if the first file in the
780 archive can be recognized as an object file, it is for this
781 target. If not, assume that this is the wrong format. If
782 the first file is not an object file, somebody is doing
783 something weird, and we permit it so that ar -t will work.
785 This is done because any normal format will recognize any
786 normal archive, regardless of the format of the object files.
787 We do accept an empty archive. */
789 first = bfd_openr_next_archived_file (abfd, NULL);
790 if (first != NULL)
792 first->target_defaulted = FALSE;
793 if (bfd_check_format (first, bfd_object)
794 && first->xvec != abfd->xvec)
796 bfd_set_error (bfd_error_wrong_object_format);
797 bfd_ardata (abfd) = tdata_hold;
798 return NULL;
800 /* And we ought to close `first' here too. */
804 return abfd->xvec;
807 /* Some constants for a 32 bit BSD archive structure. We do not
808 support 64 bit archives presently; so far as I know, none actually
809 exist. Supporting them would require changing these constants, and
810 changing some H_GET_32 to H_GET_64. */
812 /* The size of an external symdef structure. */
813 #define BSD_SYMDEF_SIZE 8
815 /* The offset from the start of a symdef structure to the file offset. */
816 #define BSD_SYMDEF_OFFSET_SIZE 4
818 /* The size of the symdef count. */
819 #define BSD_SYMDEF_COUNT_SIZE 4
821 /* The size of the string count. */
822 #define BSD_STRING_COUNT_SIZE 4
824 /* Read a BSD-style archive symbol table. Returns FALSE on error,
825 TRUE otherwise. */
827 static bfd_boolean
828 do_slurp_bsd_armap (bfd *abfd)
830 struct areltdata *mapdata;
831 unsigned int counter;
832 bfd_byte *raw_armap, *rbase;
833 struct artdata *ardata = bfd_ardata (abfd);
834 char *stringbase;
835 bfd_size_type parsed_size, amt;
836 carsym *set;
838 mapdata = _bfd_read_ar_hdr (abfd);
839 if (mapdata == NULL)
840 return FALSE;
841 parsed_size = mapdata->parsed_size;
842 bfd_release (abfd, mapdata); /* Don't need it any more. */
844 raw_armap = bfd_zalloc (abfd, parsed_size);
845 if (raw_armap == NULL)
846 return FALSE;
848 if (bfd_bread (raw_armap, parsed_size, abfd) != parsed_size)
850 if (bfd_get_error () != bfd_error_system_call)
851 bfd_set_error (bfd_error_malformed_archive);
852 byebye:
853 bfd_release (abfd, raw_armap);
854 return FALSE;
857 ardata->symdef_count = H_GET_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE;
859 if (ardata->symdef_count * BSD_SYMDEF_SIZE >
860 parsed_size - BSD_SYMDEF_COUNT_SIZE)
862 /* Probably we're using the wrong byte ordering. */
863 bfd_set_error (bfd_error_wrong_format);
864 goto byebye;
867 ardata->cache = 0;
868 rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE;
869 stringbase = ((char *) rbase
870 + ardata->symdef_count * BSD_SYMDEF_SIZE
871 + BSD_STRING_COUNT_SIZE);
872 amt = ardata->symdef_count * sizeof (carsym);
873 ardata->symdefs = bfd_alloc (abfd, amt);
874 if (!ardata->symdefs)
875 return FALSE;
877 for (counter = 0, set = ardata->symdefs;
878 counter < ardata->symdef_count;
879 counter++, set++, rbase += BSD_SYMDEF_SIZE)
881 set->name = H_GET_32 (abfd, rbase) + stringbase;
882 set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
885 ardata->first_file_filepos = bfd_tell (abfd);
886 /* Pad to an even boundary if you have to. */
887 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
888 /* FIXME, we should provide some way to free raw_ardata when
889 we are done using the strings from it. For now, it seems
890 to be allocated on an objalloc anyway... */
891 bfd_has_map (abfd) = TRUE;
892 return TRUE;
895 /* Read a COFF archive symbol table. Returns FALSE on error, TRUE
896 otherwise. */
898 static bfd_boolean
899 do_slurp_coff_armap (bfd *abfd)
901 struct areltdata *mapdata;
902 int *raw_armap, *rawptr;
903 struct artdata *ardata = bfd_ardata (abfd);
904 char *stringbase;
905 bfd_size_type stringsize;
906 unsigned int parsed_size;
907 carsym *carsyms;
908 bfd_size_type nsymz; /* Number of symbols in armap. */
909 bfd_vma (*swap) (const void *);
910 char int_buf[sizeof (long)];
911 bfd_size_type carsym_size, ptrsize;
912 unsigned int i;
914 mapdata = _bfd_read_ar_hdr (abfd);
915 if (mapdata == NULL)
916 return FALSE;
917 parsed_size = mapdata->parsed_size;
918 bfd_release (abfd, mapdata); /* Don't need it any more. */
920 if (bfd_bread (int_buf, 4, abfd) != 4)
922 if (bfd_get_error () != bfd_error_system_call)
923 bfd_set_error (bfd_error_malformed_archive);
924 return FALSE;
926 /* It seems that all numeric information in a coff archive is always
927 in big endian format, nomatter the host or target. */
928 swap = bfd_getb32;
929 nsymz = bfd_getb32 (int_buf);
930 stringsize = parsed_size - (4 * nsymz) - 4;
932 /* ... except that some archive formats are broken, and it may be our
933 fault - the i960 little endian coff sometimes has big and sometimes
934 little, because our tools changed. Here's a horrible hack to clean
935 up the crap. */
937 if (stringsize > 0xfffff
938 && bfd_get_arch (abfd) == bfd_arch_i960
939 && bfd_get_flavour (abfd) == bfd_target_coff_flavour)
941 /* This looks dangerous, let's do it the other way around. */
942 nsymz = bfd_getl32 (int_buf);
943 stringsize = parsed_size - (4 * nsymz) - 4;
944 swap = bfd_getl32;
947 /* The coff armap must be read sequentially. So we construct a
948 bsd-style one in core all at once, for simplicity. */
950 if (nsymz > ~ (bfd_size_type) 0 / sizeof (carsym))
951 return FALSE;
953 carsym_size = (nsymz * sizeof (carsym));
954 ptrsize = (4 * nsymz);
956 if (carsym_size + stringsize + 1 <= carsym_size)
957 return FALSE;
959 ardata->symdefs = bfd_zalloc (abfd, carsym_size + stringsize + 1);
960 if (ardata->symdefs == NULL)
961 return FALSE;
962 carsyms = ardata->symdefs;
963 stringbase = ((char *) ardata->symdefs) + carsym_size;
965 /* Allocate and read in the raw offsets. */
966 raw_armap = bfd_alloc (abfd, ptrsize);
967 if (raw_armap == NULL)
968 goto release_symdefs;
969 if (bfd_bread (raw_armap, ptrsize, abfd) != ptrsize
970 || (bfd_bread (stringbase, stringsize, abfd) != stringsize))
972 if (bfd_get_error () != bfd_error_system_call)
973 bfd_set_error (bfd_error_malformed_archive);
974 goto release_raw_armap;
977 /* OK, build the carsyms. */
978 for (i = 0; i < nsymz; i++)
980 rawptr = raw_armap + i;
981 carsyms->file_offset = swap ((bfd_byte *) rawptr);
982 carsyms->name = stringbase;
983 stringbase += strlen (stringbase) + 1;
984 carsyms++;
986 *stringbase = 0;
988 ardata->symdef_count = nsymz;
989 ardata->first_file_filepos = bfd_tell (abfd);
990 /* Pad to an even boundary if you have to. */
991 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
993 bfd_has_map (abfd) = TRUE;
994 bfd_release (abfd, raw_armap);
996 /* Check for a second archive header (as used by PE). */
998 struct areltdata *tmp;
1000 bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET);
1001 tmp = _bfd_read_ar_hdr (abfd);
1002 if (tmp != NULL)
1004 if (tmp->arch_header[0] == '/'
1005 && tmp->arch_header[1] == ' ')
1007 ardata->first_file_filepos +=
1008 (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1;
1010 bfd_release (abfd, tmp);
1014 return TRUE;
1016 release_raw_armap:
1017 bfd_release (abfd, raw_armap);
1018 release_symdefs:
1019 bfd_release (abfd, (ardata)->symdefs);
1020 return FALSE;
1023 /* This routine can handle either coff-style or bsd-style armaps
1024 (archive symbol table). Returns FALSE on error, TRUE otherwise */
1026 bfd_boolean
1027 bfd_slurp_armap (bfd *abfd)
1029 char nextname[17];
1030 int i = bfd_bread (nextname, 16, abfd);
1032 if (i == 0)
1033 return TRUE;
1034 if (i != 16)
1035 return FALSE;
1037 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1038 return FALSE;
1040 if (CONST_STRNEQ (nextname, "__.SYMDEF ")
1041 || CONST_STRNEQ (nextname, "__.SYMDEF/ ")) /* Old Linux archives. */
1042 return do_slurp_bsd_armap (abfd);
1043 else if (CONST_STRNEQ (nextname, "/ "))
1044 return do_slurp_coff_armap (abfd);
1045 else if (CONST_STRNEQ (nextname, "/SYM64/ "))
1047 /* 64bit ELF (Irix 6) archive. */
1048 #ifdef BFD64
1049 extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *);
1050 return bfd_elf64_archive_slurp_armap (abfd);
1051 #else
1052 bfd_set_error (bfd_error_wrong_format);
1053 return FALSE;
1054 #endif
1057 bfd_has_map (abfd) = FALSE;
1058 return TRUE;
1061 /* Returns FALSE on error, TRUE otherwise. */
1062 /* Flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
1063 header is in a slightly different order and the map name is '/'.
1064 This flavour is used by hp300hpux. */
1066 #define HPUX_SYMDEF_COUNT_SIZE 2
1068 bfd_boolean
1069 bfd_slurp_bsd_armap_f2 (bfd *abfd)
1071 struct areltdata *mapdata;
1072 char nextname[17];
1073 unsigned int counter;
1074 bfd_byte *raw_armap, *rbase;
1075 struct artdata *ardata = bfd_ardata (abfd);
1076 char *stringbase;
1077 unsigned int stringsize;
1078 bfd_size_type amt;
1079 carsym *set;
1080 int i = bfd_bread (nextname, 16, abfd);
1082 if (i == 0)
1083 return TRUE;
1084 if (i != 16)
1085 return FALSE;
1087 /* The archive has at least 16 bytes in it. */
1088 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1089 return FALSE;
1091 if (CONST_STRNEQ (nextname, "__.SYMDEF ")
1092 || CONST_STRNEQ (nextname, "__.SYMDEF/ ")) /* Old Linux archives. */
1093 return do_slurp_bsd_armap (abfd);
1095 if (! CONST_STRNEQ (nextname, "/ "))
1097 bfd_has_map (abfd) = FALSE;
1098 return TRUE;
1101 mapdata = _bfd_read_ar_hdr (abfd);
1102 if (mapdata == NULL)
1103 return FALSE;
1105 amt = mapdata->parsed_size;
1106 raw_armap = bfd_zalloc (abfd, amt);
1107 if (raw_armap == NULL)
1109 byebye:
1110 bfd_release (abfd, mapdata);
1111 return FALSE;
1114 if (bfd_bread (raw_armap, amt, abfd) != amt)
1116 if (bfd_get_error () != bfd_error_system_call)
1117 bfd_set_error (bfd_error_malformed_archive);
1118 byebyebye:
1119 bfd_release (abfd, raw_armap);
1120 goto byebye;
1123 ardata->symdef_count = H_GET_16 (abfd, raw_armap);
1125 if (ardata->symdef_count * BSD_SYMDEF_SIZE
1126 > mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE)
1128 /* Probably we're using the wrong byte ordering. */
1129 bfd_set_error (bfd_error_wrong_format);
1130 goto byebyebye;
1133 ardata->cache = 0;
1135 stringsize = H_GET_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE);
1136 /* Skip sym count and string sz. */
1137 stringbase = ((char *) raw_armap
1138 + HPUX_SYMDEF_COUNT_SIZE
1139 + BSD_STRING_COUNT_SIZE);
1140 rbase = (bfd_byte *) stringbase + stringsize;
1141 amt = ardata->symdef_count * BSD_SYMDEF_SIZE;
1142 ardata->symdefs = bfd_alloc (abfd, amt);
1143 if (!ardata->symdefs)
1144 return FALSE;
1146 for (counter = 0, set = ardata->symdefs;
1147 counter < ardata->symdef_count;
1148 counter++, set++, rbase += BSD_SYMDEF_SIZE)
1150 set->name = H_GET_32 (abfd, rbase) + stringbase;
1151 set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
1154 ardata->first_file_filepos = bfd_tell (abfd);
1155 /* Pad to an even boundary if you have to. */
1156 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1157 /* FIXME, we should provide some way to free raw_ardata when
1158 we are done using the strings from it. For now, it seems
1159 to be allocated on an objalloc anyway... */
1160 bfd_has_map (abfd) = TRUE;
1161 return TRUE;
1164 /** Extended name table.
1166 Normally archives support only 14-character filenames.
1168 Intel has extended the format: longer names are stored in a special
1169 element (the first in the archive, or second if there is an armap);
1170 the name in the ar_hdr is replaced by <space><index into filename
1171 element>. Index is the P.R. of an int (decimal). Data General have
1172 extended the format by using the prefix // for the special element. */
1174 /* Returns FALSE on error, TRUE otherwise. */
1176 bfd_boolean
1177 _bfd_slurp_extended_name_table (bfd *abfd)
1179 char nextname[17];
1180 struct areltdata *namedata;
1181 bfd_size_type amt;
1183 /* FIXME: Formatting sucks here, and in case of failure of BFD_READ,
1184 we probably don't want to return TRUE. */
1185 bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET);
1186 if (bfd_bread (nextname, 16, abfd) == 16)
1188 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1189 return FALSE;
1191 if (! CONST_STRNEQ (nextname, "ARFILENAMES/ ")
1192 && ! CONST_STRNEQ (nextname, "// "))
1194 bfd_ardata (abfd)->extended_names = NULL;
1195 bfd_ardata (abfd)->extended_names_size = 0;
1196 return TRUE;
1199 namedata = _bfd_read_ar_hdr (abfd);
1200 if (namedata == NULL)
1201 return FALSE;
1203 amt = namedata->parsed_size;
1204 if (amt + 1 == 0)
1205 goto byebye;
1207 bfd_ardata (abfd)->extended_names_size = amt;
1208 bfd_ardata (abfd)->extended_names = bfd_zalloc (abfd, amt + 1);
1209 if (bfd_ardata (abfd)->extended_names == NULL)
1211 byebye:
1212 bfd_release (abfd, namedata);
1213 return FALSE;
1216 if (bfd_bread (bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
1218 if (bfd_get_error () != bfd_error_system_call)
1219 bfd_set_error (bfd_error_malformed_archive);
1220 bfd_release (abfd, (bfd_ardata (abfd)->extended_names));
1221 bfd_ardata (abfd)->extended_names = NULL;
1222 goto byebye;
1225 /* Since the archive is supposed to be printable if it contains
1226 text, the entries in the list are newline-padded, not null
1227 padded. In SVR4-style archives, the names also have a
1228 trailing '/'. DOS/NT created archive often have \ in them
1229 We'll fix all problems here.. */
1231 char *ext_names = bfd_ardata (abfd)->extended_names;
1232 char *temp = ext_names;
1233 char *limit = temp + namedata->parsed_size;
1234 for (; temp < limit; ++temp)
1236 if (*temp == ARFMAG[1])
1237 temp[temp > ext_names && temp[-1] == '/' ? -1 : 0] = '\0';
1238 if (*temp == '\\')
1239 *temp = '/';
1241 *limit = '\0';
1244 /* Pad to an even boundary if you have to. */
1245 bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd);
1246 bfd_ardata (abfd)->first_file_filepos +=
1247 (bfd_ardata (abfd)->first_file_filepos) % 2;
1249 /* FIXME, we can't release namedata here because it was allocated
1250 below extended_names on the objalloc... */
1252 return TRUE;
1255 #ifdef VMS
1257 /* Return a copy of the stuff in the filename between any :]> and a
1258 semicolon. */
1260 static const char *
1261 normalize (bfd *abfd, const char *file)
1263 const char *first;
1264 const char *last;
1265 char *copy;
1267 first = file + strlen (file) - 1;
1268 last = first + 1;
1270 while (first != file)
1272 if (*first == ';')
1273 last = first;
1274 if (*first == ':' || *first == ']' || *first == '>')
1276 first++;
1277 break;
1279 first--;
1282 copy = bfd_alloc (abfd, last - first + 1);
1283 if (copy == NULL)
1284 return NULL;
1286 memcpy (copy, first, last - first);
1287 copy[last - first] = 0;
1289 return copy;
1292 #else
1293 static const char *
1294 normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file)
1296 const char *filename = strrchr (file, '/');
1298 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1300 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */
1301 char *bslash = strrchr (file, '\\');
1302 if (filename == NULL || (bslash != NULL && bslash > filename))
1303 filename = bslash;
1304 if (filename == NULL && file[0] != '\0' && file[1] == ':')
1305 filename = file + 1;
1307 #endif
1308 if (filename != NULL)
1309 filename++;
1310 else
1311 filename = file;
1312 return filename;
1314 #endif
1316 /* Adjust a relative path name based on the reference path. */
1318 static const char *
1319 adjust_relative_path (const char * path, const char * ref_path)
1321 static char *pathbuf = NULL;
1322 static int pathbuf_len = 0;
1323 const char *pathp = path;
1324 const char *refp = ref_path;
1325 int element_count = 0;
1326 int len;
1327 char *newp;
1329 /* Remove common leading path elements. */
1330 for (;;)
1332 const char *e1 = pathp;
1333 const char *e2 = refp;
1335 while (*e1 && ! IS_DIR_SEPARATOR (*e1))
1336 ++e1;
1337 while (*e2 && ! IS_DIR_SEPARATOR (*e2))
1338 ++e2;
1339 if (*e1 == '\0' || *e2 == '\0' || e1 - pathp != e2 - refp
1340 || strncmp (pathp, refp, e1 - pathp) != 0)
1341 break;
1342 pathp = e1 + 1;
1343 refp = e2 + 1;
1346 /* For each leading path element in the reference path,
1347 insert "../" into the path. */
1348 for (; *refp; ++refp)
1349 if (IS_DIR_SEPARATOR (*refp))
1350 ++element_count;
1351 len = 3 * element_count + strlen (path) + 1;
1353 if (len > pathbuf_len)
1355 if (pathbuf != NULL)
1356 free (pathbuf);
1357 pathbuf_len = 0;
1358 pathbuf = bfd_malloc (len);
1359 if (pathbuf == NULL)
1360 return path;
1361 pathbuf_len = len;
1364 newp = pathbuf;
1365 while (element_count-- > 0)
1367 /* FIXME: Support Windows style path separators as well. */
1368 strcpy (newp, "../");
1369 newp += 3;
1371 strcpy (newp, pathp);
1373 return pathbuf;
1376 /* Build a BFD style extended name table. */
1378 bfd_boolean
1379 _bfd_archive_bsd_construct_extended_name_table (bfd *abfd,
1380 char **tabloc,
1381 bfd_size_type *tablen,
1382 const char **name)
1384 *name = "ARFILENAMES/";
1385 return _bfd_construct_extended_name_table (abfd, FALSE, tabloc, tablen);
1388 /* Build an SVR4 style extended name table. */
1390 bfd_boolean
1391 _bfd_archive_coff_construct_extended_name_table (bfd *abfd,
1392 char **tabloc,
1393 bfd_size_type *tablen,
1394 const char **name)
1396 *name = "//";
1397 return _bfd_construct_extended_name_table (abfd, TRUE, tabloc, tablen);
1400 /* Follows archive_head and produces an extended name table if
1401 necessary. Returns (in tabloc) a pointer to an extended name
1402 table, and in tablen the length of the table. If it makes an entry
1403 it clobbers the filename so that the element may be written without
1404 further massage. Returns TRUE if it ran successfully, FALSE if
1405 something went wrong. A successful return may still involve a
1406 zero-length tablen! */
1408 bfd_boolean
1409 _bfd_construct_extended_name_table (bfd *abfd,
1410 bfd_boolean trailing_slash,
1411 char **tabloc,
1412 bfd_size_type *tablen)
1414 unsigned int maxname = abfd->xvec->ar_max_namelen;
1415 bfd_size_type total_namelen = 0;
1416 bfd *current;
1417 char *strptr;
1418 const char *last_filename;
1419 long last_stroff;
1421 *tablen = 0;
1422 last_filename = NULL;
1424 /* Figure out how long the table should be. */
1425 for (current = abfd->archive_head;
1426 current != NULL;
1427 current = current->archive_next)
1429 const char *normal;
1430 unsigned int thislen;
1432 if (bfd_is_thin_archive (abfd))
1434 const char *filename = current->filename;
1436 /* If the element being added is a member of another archive
1437 (i.e., we are flattening), use the containing archive's name. */
1438 if (current->my_archive
1439 && ! bfd_is_thin_archive (current->my_archive))
1440 filename = current->my_archive->filename;
1442 /* If the path is the same as the previous path seen,
1443 reuse it. This can happen when flattening a thin
1444 archive that contains other archives. */
1445 if (last_filename && strcmp (last_filename, filename) == 0)
1446 continue;
1448 last_filename = filename;
1450 /* If the path is relative, adjust it relative to
1451 the containing archive. */
1452 if (! IS_ABSOLUTE_PATH (filename)
1453 && ! IS_ABSOLUTE_PATH (abfd->filename))
1454 normal = adjust_relative_path (filename, abfd->filename);
1455 else
1456 normal = filename;
1458 /* In a thin archive, always store the full pathname
1459 in the extended name table. */
1460 total_namelen += strlen (normal) + 1;
1461 if (trailing_slash)
1462 /* Leave room for trailing slash. */
1463 ++total_namelen;
1465 continue;
1468 normal = normalize (current, current->filename);
1469 if (normal == NULL)
1470 return FALSE;
1472 thislen = strlen (normal);
1474 if (thislen > maxname
1475 && (bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1476 thislen = maxname;
1478 if (thislen > maxname)
1480 /* Add one to leave room for \n. */
1481 total_namelen += thislen + 1;
1482 if (trailing_slash)
1484 /* Leave room for trailing slash. */
1485 ++total_namelen;
1488 else
1490 struct ar_hdr *hdr = arch_hdr (current);
1491 if (strncmp (normal, hdr->ar_name, thislen) != 0
1492 || (thislen < sizeof hdr->ar_name
1493 && hdr->ar_name[thislen] != ar_padchar (current)))
1495 /* Must have been using extended format even though it
1496 didn't need to. Fix it to use normal format. */
1497 memcpy (hdr->ar_name, normal, thislen);
1498 if (thislen < maxname
1499 || (thislen == maxname && thislen < sizeof hdr->ar_name))
1500 hdr->ar_name[thislen] = ar_padchar (current);
1505 if (total_namelen == 0)
1506 return TRUE;
1508 *tabloc = bfd_zalloc (abfd, total_namelen);
1509 if (*tabloc == NULL)
1510 return FALSE;
1512 *tablen = total_namelen;
1513 strptr = *tabloc;
1515 last_filename = NULL;
1516 last_stroff = 0;
1518 for (current = abfd->archive_head;
1519 current != NULL;
1520 current = current->archive_next)
1522 const char *normal;
1523 unsigned int thislen;
1524 long stroff;
1525 const char *filename = current->filename;
1527 if (bfd_is_thin_archive (abfd))
1529 /* If the element being added is a member of another archive
1530 (i.e., we are flattening), use the containing archive's name. */
1531 if (current->my_archive
1532 && ! bfd_is_thin_archive (current->my_archive))
1533 filename = current->my_archive->filename;
1534 /* If the path is the same as the previous path seen,
1535 reuse it. This can happen when flattening a thin
1536 archive that contains other archives.
1537 If the path is relative, adjust it relative to
1538 the containing archive. */
1539 if (last_filename && strcmp (last_filename, filename) == 0)
1540 normal = last_filename;
1541 else if (! IS_ABSOLUTE_PATH (filename)
1542 && ! IS_ABSOLUTE_PATH (abfd->filename))
1543 normal = adjust_relative_path (filename, abfd->filename);
1544 else
1545 normal = filename;
1547 else
1549 normal = normalize (current, filename);
1550 if (normal == NULL)
1551 return FALSE;
1554 thislen = strlen (normal);
1555 if (thislen > maxname || bfd_is_thin_archive (abfd))
1557 /* Works for now; may need to be re-engineered if we
1558 encounter an oddball archive format and want to
1559 generalise this hack. */
1560 struct ar_hdr *hdr = arch_hdr (current);
1561 if (normal == last_filename)
1562 stroff = last_stroff;
1563 else
1565 strcpy (strptr, normal);
1566 if (! trailing_slash)
1567 strptr[thislen] = ARFMAG[1];
1568 else
1570 strptr[thislen] = '/';
1571 strptr[thislen + 1] = ARFMAG[1];
1573 stroff = strptr - *tabloc;
1574 last_stroff = stroff;
1576 hdr->ar_name[0] = ar_padchar (current);
1577 if (bfd_is_thin_archive (abfd) && current->origin > 0)
1579 int len = snprintf (hdr->ar_name + 1, maxname - 1, "%-ld:",
1580 stroff);
1581 _bfd_ar_spacepad (hdr->ar_name + 1 + len, maxname - 1 - len,
1582 "%-ld",
1583 current->origin - sizeof (struct ar_hdr));
1585 else
1586 _bfd_ar_spacepad (hdr->ar_name + 1, maxname - 1, "%-ld", stroff);
1587 if (normal != last_filename)
1589 strptr += thislen + 1;
1590 if (trailing_slash)
1591 ++strptr;
1592 last_filename = filename;
1597 return TRUE;
1600 /* A couple of functions for creating ar_hdrs. */
1602 #ifdef HPUX_LARGE_AR_IDS
1603 /* Function to encode large UID/GID values according to HP. */
1605 static void
1606 hpux_uid_gid_encode (char str[6], long int id)
1608 int cnt;
1610 str[5] = '@' + (id & 3);
1611 id >>= 2;
1613 for (cnt = 4; cnt >= 0; --cnt, id >>= 6)
1614 str[cnt] = ' ' + (id & 0x3f);
1616 #endif /* HPUX_LARGE_AR_IDS */
1618 #ifndef HAVE_GETUID
1619 #define getuid() 0
1620 #endif
1622 #ifndef HAVE_GETGID
1623 #define getgid() 0
1624 #endif
1626 /* Takes a filename, returns an arelt_data for it, or NULL if it can't
1627 make one. The filename must refer to a filename in the filesystem.
1628 The filename field of the ar_hdr will NOT be initialized. If member
1629 is set, and it's an in-memory bfd, we fake it. */
1631 static struct areltdata *
1632 bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
1634 struct stat status;
1635 struct areltdata *ared;
1636 struct ar_hdr *hdr;
1637 bfd_size_type amt;
1639 if (member && (member->flags & BFD_IN_MEMORY) != 0)
1641 /* Assume we just "made" the member, and fake it. */
1642 struct bfd_in_memory *bim = member->iostream;
1643 time (&status.st_mtime);
1644 status.st_uid = getuid ();
1645 status.st_gid = getgid ();
1646 status.st_mode = 0644;
1647 status.st_size = bim->size;
1649 else if (stat (filename, &status) != 0)
1651 bfd_set_error (bfd_error_system_call);
1652 return NULL;
1655 amt = sizeof (struct ar_hdr) + sizeof (struct areltdata);
1656 ared = bfd_zalloc (abfd, amt);
1657 if (ared == NULL)
1658 return NULL;
1659 hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));
1661 /* ar headers are space padded, not null padded! */
1662 memset (hdr, ' ', sizeof (struct ar_hdr));
1664 _bfd_ar_spacepad (hdr->ar_date, sizeof (hdr->ar_date), "%-12ld",
1665 status.st_mtime);
1666 #ifdef HPUX_LARGE_AR_IDS
1667 /* HP has a very "special" way to handle UID/GID's with numeric values
1668 > 99999. */
1669 if (status.st_uid > 99999)
1670 hpux_uid_gid_encode (hdr->ar_uid, (long) status.st_uid);
1671 else
1672 #endif
1673 _bfd_ar_spacepad (hdr->ar_uid, sizeof (hdr->ar_uid), "%ld",
1674 status.st_uid);
1675 #ifdef HPUX_LARGE_AR_IDS
1676 /* HP has a very "special" way to handle UID/GID's with numeric values
1677 > 99999. */
1678 if (status.st_gid > 99999)
1679 hpux_uid_gid_encode (hdr->ar_gid, (long) status.st_gid);
1680 else
1681 #endif
1682 _bfd_ar_spacepad (hdr->ar_gid, sizeof (hdr->ar_gid), "%ld",
1683 status.st_gid);
1684 _bfd_ar_spacepad (hdr->ar_mode, sizeof (hdr->ar_mode), "%-8lo",
1685 status.st_mode);
1686 _bfd_ar_spacepad (hdr->ar_size, sizeof (hdr->ar_size), "%-10ld",
1687 status.st_size);
1688 memcpy (hdr->ar_fmag, ARFMAG, 2);
1689 ared->parsed_size = status.st_size;
1690 ared->arch_header = (char *) hdr;
1692 return ared;
1695 /* This is magic required by the "ar" program. Since it's
1696 undocumented, it's undocumented. You may think that it would take
1697 a strong stomach to write this, and it does, but it takes even a
1698 stronger stomach to try to code around such a thing! */
1700 struct ar_hdr *bfd_special_undocumented_glue (bfd *, const char *);
1702 struct ar_hdr *
1703 bfd_special_undocumented_glue (bfd *abfd, const char *filename)
1705 struct areltdata *ar_elt = bfd_ar_hdr_from_filesystem (abfd, filename, 0);
1706 if (ar_elt == NULL)
1707 return NULL;
1708 return (struct ar_hdr *) ar_elt->arch_header;
1711 /* Analogous to stat call. */
1714 bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
1716 struct ar_hdr *hdr;
1717 char *aloser;
1719 if (abfd->arelt_data == NULL)
1721 bfd_set_error (bfd_error_invalid_operation);
1722 return -1;
1725 hdr = arch_hdr (abfd);
1727 #define foo(arelt, stelt, size) \
1728 buf->stelt = strtol (hdr->arelt, &aloser, size); \
1729 if (aloser == hdr->arelt) \
1730 return -1;
1732 /* Some platforms support special notations for large IDs. */
1733 #ifdef HPUX_LARGE_AR_IDS
1734 # define foo2(arelt, stelt, size) \
1735 if (hdr->arelt[5] == ' ') \
1737 foo (arelt, stelt, size); \
1739 else \
1741 int cnt; \
1742 for (buf->stelt = cnt = 0; cnt < 5; ++cnt) \
1744 if (hdr->arelt[cnt] < ' ' || hdr->arelt[cnt] > ' ' + 0x3f) \
1745 return -1; \
1746 buf->stelt <<= 6; \
1747 buf->stelt += hdr->arelt[cnt] - ' '; \
1749 if (hdr->arelt[5] < '@' || hdr->arelt[5] > '@' + 3) \
1750 return -1; \
1751 buf->stelt <<= 2; \
1752 buf->stelt += hdr->arelt[5] - '@'; \
1754 #else
1755 # define foo2(arelt, stelt, size) foo (arelt, stelt, size)
1756 #endif
1758 foo (ar_date, st_mtime, 10);
1759 foo2 (ar_uid, st_uid, 10);
1760 foo2 (ar_gid, st_gid, 10);
1761 foo (ar_mode, st_mode, 8);
1763 buf->st_size = arch_eltdata (abfd)->parsed_size;
1765 return 0;
1768 void
1769 bfd_dont_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1771 /* FIXME: This interacts unpleasantly with ar's quick-append option.
1772 Fortunately ic960 users will never use that option. Fixing this
1773 is very hard; fortunately I know how to do it and will do so once
1774 intel's release is out the door. */
1776 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1777 size_t length;
1778 const char *filename;
1779 size_t maxlen = ar_maxnamelen (abfd);
1781 if ((bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1783 bfd_bsd_truncate_arname (abfd, pathname, arhdr);
1784 return;
1787 filename = normalize (abfd, pathname);
1788 if (filename == NULL)
1790 /* FIXME */
1791 abort ();
1794 length = strlen (filename);
1796 if (length <= maxlen)
1797 memcpy (hdr->ar_name, filename, length);
1799 /* Add the padding character if there is room for it. */
1800 if (length < maxlen
1801 || (length == maxlen && length < sizeof hdr->ar_name))
1802 (hdr->ar_name)[length] = ar_padchar (abfd);
1805 void
1806 bfd_bsd_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1808 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1809 size_t length;
1810 const char *filename = strrchr (pathname, '/');
1811 size_t maxlen = ar_maxnamelen (abfd);
1813 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1815 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */
1816 char *bslash = strrchr (pathname, '\\');
1817 if (filename == NULL || (bslash != NULL && bslash > filename))
1818 filename = bslash;
1819 if (filename == NULL && pathname[0] != '\0' && pathname[1] == ':')
1820 filename = pathname + 1;
1822 #endif
1824 if (filename == NULL)
1825 filename = pathname;
1826 else
1827 ++filename;
1829 length = strlen (filename);
1831 if (length <= maxlen)
1832 memcpy (hdr->ar_name, filename, length);
1833 else
1835 /* pathname: meet procrustes */
1836 memcpy (hdr->ar_name, filename, maxlen);
1837 length = maxlen;
1840 if (length < maxlen)
1841 (hdr->ar_name)[length] = ar_padchar (abfd);
1844 /* Store name into ar header. Truncates the name to fit.
1845 1> strip pathname to be just the basename.
1846 2> if it's short enuf to fit, stuff it in.
1847 3> If it doesn't end with .o, truncate it to fit
1848 4> truncate it before the .o, append .o, stuff THAT in. */
1850 /* This is what gnu ar does. It's better but incompatible with the
1851 bsd ar. */
1853 void
1854 bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1856 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1857 size_t length;
1858 const char *filename = strrchr (pathname, '/');
1859 size_t maxlen = ar_maxnamelen (abfd);
1861 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1863 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */
1864 char *bslash = strrchr (pathname, '\\');
1866 if (filename == NULL || (bslash != NULL && bslash > filename))
1867 filename = bslash;
1868 if (filename == NULL && pathname[0] != '\0' && pathname[1] == ':')
1869 filename = pathname + 1;
1871 #endif
1873 if (filename == NULL)
1874 filename = pathname;
1875 else
1876 ++filename;
1878 length = strlen (filename);
1880 if (length <= maxlen)
1881 memcpy (hdr->ar_name, filename, length);
1882 else
1884 /* pathname: meet procrustes. */
1885 memcpy (hdr->ar_name, filename, maxlen);
1886 if ((filename[length - 2] == '.') && (filename[length - 1] == 'o'))
1888 hdr->ar_name[maxlen - 2] = '.';
1889 hdr->ar_name[maxlen - 1] = 'o';
1891 length = maxlen;
1894 if (length < 16)
1895 (hdr->ar_name)[length] = ar_padchar (abfd);
1898 /* The BFD is open for write and has its format set to bfd_archive. */
1900 bfd_boolean
1901 _bfd_write_archive_contents (bfd *arch)
1903 bfd *current;
1904 char *etable = NULL;
1905 bfd_size_type elength = 0;
1906 const char *ename = NULL;
1907 bfd_boolean makemap = bfd_has_map (arch);
1908 /* If no .o's, don't bother to make a map. */
1909 bfd_boolean hasobjects = FALSE;
1910 bfd_size_type wrote;
1911 int tries;
1912 char *armag;
1914 /* Verify the viability of all entries; if any of them live in the
1915 filesystem (as opposed to living in an archive open for input)
1916 then construct a fresh ar_hdr for them. */
1917 for (current = arch->archive_head;
1918 current != NULL;
1919 current = current->archive_next)
1921 /* This check is checking the bfds for the objects we're reading
1922 from (which are usually either an object file or archive on
1923 disk), not the archive entries we're writing to. We don't
1924 actually create bfds for the archive members, we just copy
1925 them byte-wise when we write out the archive. */
1926 if (bfd_write_p (current))
1928 bfd_set_error (bfd_error_invalid_operation);
1929 goto input_err;
1931 if (!current->arelt_data)
1933 current->arelt_data =
1934 bfd_ar_hdr_from_filesystem (arch, current->filename, current);
1935 if (!current->arelt_data)
1936 goto input_err;
1938 /* Put in the file name. */
1939 BFD_SEND (arch, _bfd_truncate_arname,
1940 (arch, current->filename, (char *) arch_hdr (current)));
1943 if (makemap && ! hasobjects)
1944 { /* Don't bother if we won't make a map! */
1945 if ((bfd_check_format (current, bfd_object)))
1946 hasobjects = TRUE;
1950 if (!BFD_SEND (arch, _bfd_construct_extended_name_table,
1951 (arch, &etable, &elength, &ename)))
1952 return FALSE;
1954 if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0)
1955 return FALSE;
1956 armag = ARMAG;
1957 if (bfd_is_thin_archive (arch))
1958 armag = ARMAGT;
1959 wrote = bfd_bwrite (armag, SARMAG, arch);
1960 if (wrote != SARMAG)
1961 return FALSE;
1963 if (makemap && hasobjects)
1965 if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength))
1966 return FALSE;
1969 if (elength != 0)
1971 struct ar_hdr hdr;
1973 memset (&hdr, ' ', sizeof (struct ar_hdr));
1974 memcpy (hdr.ar_name, ename, strlen (ename));
1975 /* Round size up to even number in archive header. */
1976 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld",
1977 (elength + 1) & ~(bfd_size_type) 1);
1978 memcpy (hdr.ar_fmag, ARFMAG, 2);
1979 if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
1980 != sizeof (struct ar_hdr))
1981 || bfd_bwrite (etable, elength, arch) != elength)
1982 return FALSE;
1983 if ((elength % 2) == 1)
1985 if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)
1986 return FALSE;
1990 for (current = arch->archive_head;
1991 current != NULL;
1992 current = current->archive_next)
1994 char buffer[DEFAULT_BUFFERSIZE];
1995 unsigned int remaining = arelt_size (current);
1996 struct ar_hdr *hdr = arch_hdr (current);
1998 /* Write ar header. */
1999 if (bfd_bwrite (hdr, sizeof (*hdr), arch)
2000 != sizeof (*hdr))
2001 return FALSE;
2002 if (bfd_is_thin_archive (arch))
2003 continue;
2004 if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
2005 goto input_err;
2007 while (remaining)
2009 unsigned int amt = DEFAULT_BUFFERSIZE;
2011 if (amt > remaining)
2012 amt = remaining;
2013 errno = 0;
2014 if (bfd_bread (buffer, amt, current) != amt)
2016 if (bfd_get_error () != bfd_error_system_call)
2017 bfd_set_error (bfd_error_file_truncated);
2018 goto input_err;
2020 if (bfd_bwrite (buffer, amt, arch) != amt)
2021 return FALSE;
2022 remaining -= amt;
2025 if ((arelt_size (current) % 2) == 1)
2027 if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)
2028 return FALSE;
2032 if (makemap && hasobjects)
2034 /* Verify the timestamp in the archive file. If it would not be
2035 accepted by the linker, rewrite it until it would be. If
2036 anything odd happens, break out and just return. (The
2037 Berkeley linker checks the timestamp and refuses to read the
2038 table-of-contents if it is >60 seconds less than the file's
2039 modified-time. That painful hack requires this painful hack. */
2040 tries = 1;
2043 if (bfd_update_armap_timestamp (arch))
2044 break;
2045 (*_bfd_error_handler)
2046 (_("Warning: writing archive was slow: rewriting timestamp\n"));
2048 while (++tries < 6);
2051 return TRUE;
2053 input_err:
2054 bfd_set_error (bfd_error_on_input, current, bfd_get_error ());
2055 return FALSE;
2058 /* Note that the namidx for the first symbol is 0. */
2060 bfd_boolean
2061 _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
2063 char *first_name = NULL;
2064 bfd *current;
2065 file_ptr elt_no = 0;
2066 struct orl *map = NULL;
2067 unsigned int orl_max = 1024; /* Fine initial default. */
2068 unsigned int orl_count = 0;
2069 int stridx = 0;
2070 asymbol **syms = NULL;
2071 long syms_max = 0;
2072 bfd_boolean ret;
2073 bfd_size_type amt;
2075 /* Dunno if this is the best place for this info... */
2076 if (elength != 0)
2077 elength += sizeof (struct ar_hdr);
2078 elength += elength % 2;
2080 amt = orl_max * sizeof (struct orl);
2081 map = bfd_malloc (amt);
2082 if (map == NULL)
2083 goto error_return;
2085 /* We put the symbol names on the arch objalloc, and then discard
2086 them when done. */
2087 first_name = bfd_alloc (arch, 1);
2088 if (first_name == NULL)
2089 goto error_return;
2091 /* Drop all the files called __.SYMDEF, we're going to make our own. */
2092 while (arch->archive_head
2093 && strcmp (arch->archive_head->filename, "__.SYMDEF") == 0)
2094 arch->archive_head = arch->archive_head->archive_next;
2096 /* Map over each element. */
2097 for (current = arch->archive_head;
2098 current != NULL;
2099 current = current->archive_next, elt_no++)
2101 if (bfd_check_format (current, bfd_object)
2102 && (bfd_get_file_flags (current) & HAS_SYMS) != 0)
2104 long storage;
2105 long symcount;
2106 long src_count;
2108 storage = bfd_get_symtab_upper_bound (current);
2109 if (storage < 0)
2110 goto error_return;
2112 if (storage != 0)
2114 if (storage > syms_max)
2116 if (syms_max > 0)
2117 free (syms);
2118 syms_max = storage;
2119 syms = bfd_malloc (syms_max);
2120 if (syms == NULL)
2121 goto error_return;
2123 symcount = bfd_canonicalize_symtab (current, syms);
2124 if (symcount < 0)
2125 goto error_return;
2127 /* Now map over all the symbols, picking out the ones we
2128 want. */
2129 for (src_count = 0; src_count < symcount; src_count++)
2131 flagword flags = (syms[src_count])->flags;
2132 asection *sec = syms[src_count]->section;
2134 if ((flags & BSF_GLOBAL
2135 || flags & BSF_WEAK
2136 || flags & BSF_INDIRECT
2137 || bfd_is_com_section (sec))
2138 && ! bfd_is_und_section (sec))
2140 bfd_size_type namelen;
2141 struct orl *new_map;
2143 /* This symbol will go into the archive header. */
2144 if (orl_count == orl_max)
2146 orl_max *= 2;
2147 amt = orl_max * sizeof (struct orl);
2148 new_map = bfd_realloc (map, amt);
2149 if (new_map == NULL)
2150 goto error_return;
2152 map = new_map;
2155 namelen = strlen (syms[src_count]->name);
2156 amt = sizeof (char *);
2157 map[orl_count].name = bfd_alloc (arch, amt);
2158 if (map[orl_count].name == NULL)
2159 goto error_return;
2160 *(map[orl_count].name) = bfd_alloc (arch, namelen + 1);
2161 if (*(map[orl_count].name) == NULL)
2162 goto error_return;
2163 strcpy (*(map[orl_count].name), syms[src_count]->name);
2164 map[orl_count].u.abfd = current;
2165 map[orl_count].namidx = stridx;
2167 stridx += namelen + 1;
2168 ++orl_count;
2173 /* Now ask the BFD to free up any cached information, so we
2174 don't fill all of memory with symbol tables. */
2175 if (! bfd_free_cached_info (current))
2176 goto error_return;
2180 /* OK, now we have collected all the data, let's write them out. */
2181 ret = BFD_SEND (arch, write_armap,
2182 (arch, elength, map, orl_count, stridx));
2184 if (syms_max > 0)
2185 free (syms);
2186 if (map != NULL)
2187 free (map);
2188 if (first_name != NULL)
2189 bfd_release (arch, first_name);
2191 return ret;
2193 error_return:
2194 if (syms_max > 0)
2195 free (syms);
2196 if (map != NULL)
2197 free (map);
2198 if (first_name != NULL)
2199 bfd_release (arch, first_name);
2201 return FALSE;
2204 bfd_boolean
2205 bsd_write_armap (bfd *arch,
2206 unsigned int elength,
2207 struct orl *map,
2208 unsigned int orl_count,
2209 int stridx)
2211 int padit = stridx & 1;
2212 unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE;
2213 unsigned int stringsize = stridx + padit;
2214 /* Include 8 bytes to store ranlibsize and stringsize in output. */
2215 unsigned int mapsize = ranlibsize + stringsize + 8;
2216 file_ptr firstreal;
2217 bfd *current = arch->archive_head;
2218 bfd *last_elt = current; /* Last element arch seen. */
2219 bfd_byte temp[4];
2220 unsigned int count;
2221 struct ar_hdr hdr;
2222 struct stat statbuf;
2224 firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
2226 stat (arch->filename, &statbuf);
2227 memset (&hdr, ' ', sizeof (struct ar_hdr));
2228 memcpy (hdr.ar_name, RANLIBMAG, strlen (RANLIBMAG));
2229 /* Remember the timestamp, to keep it holy. But fudge it a little. */
2230 bfd_ardata (arch)->armap_timestamp = statbuf.st_mtime + ARMAP_TIME_OFFSET;
2231 bfd_ardata (arch)->armap_datepos = (SARMAG
2232 + offsetof (struct ar_hdr, ar_date[0]));
2233 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2234 bfd_ardata (arch)->armap_timestamp);
2235 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", getuid ());
2236 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", getgid ());
2237 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld", mapsize);
2238 memcpy (hdr.ar_fmag, ARFMAG, 2);
2239 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2240 != sizeof (struct ar_hdr))
2241 return FALSE;
2242 H_PUT_32 (arch, ranlibsize, temp);
2243 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
2244 return FALSE;
2246 for (count = 0; count < orl_count; count++)
2248 bfd_byte buf[BSD_SYMDEF_SIZE];
2250 if (map[count].u.abfd != last_elt)
2254 firstreal += arelt_size (current) + sizeof (struct ar_hdr);
2255 firstreal += firstreal % 2;
2256 current = current->archive_next;
2258 while (current != map[count].u.abfd);
2261 last_elt = current;
2262 H_PUT_32 (arch, map[count].namidx, buf);
2263 H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE);
2264 if (bfd_bwrite (buf, BSD_SYMDEF_SIZE, arch)
2265 != BSD_SYMDEF_SIZE)
2266 return FALSE;
2269 /* Now write the strings themselves. */
2270 H_PUT_32 (arch, stringsize, temp);
2271 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
2272 return FALSE;
2273 for (count = 0; count < orl_count; count++)
2275 size_t len = strlen (*map[count].name) + 1;
2277 if (bfd_bwrite (*map[count].name, len, arch) != len)
2278 return FALSE;
2281 /* The spec sez this should be a newline. But in order to be
2282 bug-compatible for sun's ar we use a null. */
2283 if (padit)
2285 if (bfd_bwrite ("", 1, arch) != 1)
2286 return FALSE;
2289 return TRUE;
2292 /* At the end of archive file handling, update the timestamp in the
2293 file, so the linker will accept it.
2295 Return TRUE if the timestamp was OK, or an unusual problem happened.
2296 Return FALSE if we updated the timestamp. */
2298 bfd_boolean
2299 _bfd_archive_bsd_update_armap_timestamp (bfd *arch)
2301 struct stat archstat;
2302 struct ar_hdr hdr;
2304 /* Flush writes, get last-write timestamp from file, and compare it
2305 to the timestamp IN the file. */
2306 bfd_flush (arch);
2307 if (bfd_stat (arch, &archstat) == -1)
2309 bfd_perror (_("Reading archive file mod timestamp"));
2311 /* Can't read mod time for some reason. */
2312 return TRUE;
2314 if (((long) archstat.st_mtime) <= bfd_ardata (arch)->armap_timestamp)
2315 /* OK by the linker's rules. */
2316 return TRUE;
2318 /* Update the timestamp. */
2319 bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET;
2321 /* Prepare an ASCII version suitable for writing. */
2322 memset (hdr.ar_date, ' ', sizeof (hdr.ar_date));
2323 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2324 bfd_ardata (arch)->armap_timestamp);
2326 /* Write it into the file. */
2327 bfd_ardata (arch)->armap_datepos = (SARMAG
2328 + offsetof (struct ar_hdr, ar_date[0]));
2329 if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0
2330 || (bfd_bwrite (hdr.ar_date, sizeof (hdr.ar_date), arch)
2331 != sizeof (hdr.ar_date)))
2333 bfd_perror (_("Writing updated armap timestamp"));
2335 /* Some error while writing. */
2336 return TRUE;
2339 /* We updated the timestamp successfully. */
2340 return FALSE;
2343 /* A coff armap looks like :
2344 lARMAG
2345 struct ar_hdr with name = '/'
2346 number of symbols
2347 offset of file for symbol 0
2348 offset of file for symbol 1
2350 offset of file for symbol n-1
2351 symbol name 0
2352 symbol name 1
2354 symbol name n-1 */
2356 bfd_boolean
2357 coff_write_armap (bfd *arch,
2358 unsigned int elength,
2359 struct orl *map,
2360 unsigned int symbol_count,
2361 int stridx)
2363 /* The size of the ranlib is the number of exported symbols in the
2364 archive * the number of bytes in an int, + an int for the count. */
2365 unsigned int ranlibsize = (symbol_count * 4) + 4;
2366 unsigned int stringsize = stridx;
2367 unsigned int mapsize = stringsize + ranlibsize;
2368 unsigned int archive_member_file_ptr;
2369 bfd *current = arch->archive_head;
2370 unsigned int count;
2371 struct ar_hdr hdr;
2372 int padit = mapsize & 1;
2374 if (padit)
2375 mapsize++;
2377 /* Work out where the first object file will go in the archive. */
2378 archive_member_file_ptr = (mapsize
2379 + elength
2380 + sizeof (struct ar_hdr)
2381 + SARMAG);
2383 memset (&hdr, ' ', sizeof (struct ar_hdr));
2384 hdr.ar_name[0] = '/';
2385 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld",
2386 mapsize);
2387 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2388 time (NULL));
2389 /* This, at least, is what Intel coff sets the values to. */
2390 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", 0);
2391 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", 0);
2392 _bfd_ar_spacepad (hdr.ar_mode, sizeof (hdr.ar_mode), "%-7lo", 0);
2393 memcpy (hdr.ar_fmag, ARFMAG, 2);
2395 /* Write the ar header for this item and the number of symbols. */
2396 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2397 != sizeof (struct ar_hdr))
2398 return FALSE;
2400 if (!bfd_write_bigendian_4byte_int (arch, symbol_count))
2401 return FALSE;
2403 /* Two passes, first write the file offsets for each symbol -
2404 remembering that each offset is on a two byte boundary. */
2406 /* Write out the file offset for the file associated with each
2407 symbol, and remember to keep the offsets padded out. */
2409 current = arch->archive_head;
2410 count = 0;
2411 while (current != NULL && count < symbol_count)
2413 /* For each symbol which is used defined in this object, write
2414 out the object file's address in the archive. */
2416 while (count < symbol_count && map[count].u.abfd == current)
2418 if (!bfd_write_bigendian_4byte_int (arch, archive_member_file_ptr))
2419 return FALSE;
2420 count++;
2422 archive_member_file_ptr += sizeof (struct ar_hdr);
2423 if (! bfd_is_thin_archive (arch))
2425 /* Add size of this archive entry. */
2426 archive_member_file_ptr += arelt_size (current);
2427 /* Remember about the even alignment. */
2428 archive_member_file_ptr += archive_member_file_ptr % 2;
2430 current = current->archive_next;
2433 /* Now write the strings themselves. */
2434 for (count = 0; count < symbol_count; count++)
2436 size_t len = strlen (*map[count].name) + 1;
2438 if (bfd_bwrite (*map[count].name, len, arch) != len)
2439 return FALSE;
2442 /* The spec sez this should be a newline. But in order to be
2443 bug-compatible for arc960 we use a null. */
2444 if (padit)
2446 if (bfd_bwrite ("", 1, arch) != 1)
2447 return FALSE;
2450 return TRUE;