2006-03-20 Paul Brook <paul@codesourcery.com>
[binutils.git] / bfd / archive.c
blob5a12f01f7cc50822811a44bac641438734d66e1f
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
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 "bfd.h"
133 #include "sysdep.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"
141 #ifndef errno
142 extern int errno;
143 #endif
145 /* We keep a cache of archive filepointers to archive elements to
146 speed up searching the archive by filepos. We only add an entry to
147 the cache when we actually read one. We also don't sort the cache;
148 it's generally short enough to search linearly.
149 Note that the pointers here point to the front of the ar_hdr, not
150 to the front of the contents! */
151 struct ar_cache {
152 file_ptr ptr;
153 bfd *arbfd;
156 #define ar_padchar(abfd) ((abfd)->xvec->ar_pad_char)
157 #define ar_maxnamelen(abfd) ((abfd)->xvec->ar_max_namelen)
159 #define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data))
160 #define arch_hdr(bfd) ((struct ar_hdr *) arch_eltdata(bfd)->arch_header)
162 void
163 _bfd_ar_spacepad (char *p, size_t n, const char *fmt, long val)
165 static char buf[20];
166 size_t len;
167 snprintf (buf, sizeof (buf), fmt, val);
168 len = strlen (buf);
169 if (len < n)
171 memcpy (p, buf, len);
172 memset (p + len, ' ', n - len);
174 else
175 memcpy (p, buf, n);
178 bfd_boolean
179 _bfd_generic_mkarchive (bfd *abfd)
181 bfd_size_type amt = sizeof (struct artdata);
183 abfd->tdata.aout_ar_data = bfd_zalloc (abfd, amt);
184 if (bfd_ardata (abfd) == NULL)
185 return FALSE;
187 /* Already cleared by bfd_zalloc above.
188 bfd_ardata (abfd)->cache = NULL;
189 bfd_ardata (abfd)->archive_head = NULL;
190 bfd_ardata (abfd)->symdefs = NULL;
191 bfd_ardata (abfd)->extended_names = NULL;
192 bfd_ardata (abfd)->extended_names_size = 0;
193 bfd_ardata (abfd)->tdata = NULL; */
195 return TRUE;
199 FUNCTION
200 bfd_get_next_mapent
202 SYNOPSIS
203 symindex bfd_get_next_mapent
204 (bfd *abfd, symindex previous, carsym **sym);
206 DESCRIPTION
207 Step through archive @var{abfd}'s symbol table (if it
208 has one). Successively update @var{sym} with the next symbol's
209 information, returning that symbol's (internal) index into the
210 symbol table.
212 Supply <<BFD_NO_MORE_SYMBOLS>> as the @var{previous} entry to get
213 the first one; returns <<BFD_NO_MORE_SYMBOLS>> when you've already
214 got the last one.
216 A <<carsym>> is a canonical archive symbol. The only
217 user-visible element is its name, a null-terminated string.
220 symindex
221 bfd_get_next_mapent (bfd *abfd, symindex prev, carsym **entry)
223 if (!bfd_has_map (abfd))
225 bfd_set_error (bfd_error_invalid_operation);
226 return BFD_NO_MORE_SYMBOLS;
229 if (prev == BFD_NO_MORE_SYMBOLS)
230 prev = 0;
231 else
232 ++prev;
233 if (prev >= bfd_ardata (abfd)->symdef_count)
234 return BFD_NO_MORE_SYMBOLS;
236 *entry = (bfd_ardata (abfd)->symdefs + prev);
237 return prev;
240 /* To be called by backends only. */
242 bfd *
243 _bfd_create_empty_archive_element_shell (bfd *obfd)
245 return _bfd_new_bfd_contained_in (obfd);
249 FUNCTION
250 bfd_set_archive_head
252 SYNOPSIS
253 bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);
255 DESCRIPTION
256 Set the head of the chain of
257 BFDs contained in the archive @var{output} to @var{new_head}.
260 bfd_boolean
261 bfd_set_archive_head (bfd *output_archive, bfd *new_head)
263 output_archive->archive_head = new_head;
264 return TRUE;
267 bfd *
268 _bfd_look_for_bfd_in_cache (bfd *arch_bfd, file_ptr filepos)
270 htab_t hash_table = bfd_ardata (arch_bfd)->cache;
271 struct ar_cache m;
272 m.ptr = filepos;
274 if (hash_table)
276 struct ar_cache *entry = (struct ar_cache *) htab_find (hash_table, &m);
277 if (!entry)
278 return NULL;
279 else
280 return entry->arbfd;
282 else
283 return NULL;
286 static hashval_t
287 hash_file_ptr (const PTR p)
289 return (hashval_t) (((struct ar_cache *) p)->ptr);
292 /* Returns non-zero if P1 and P2 are equal. */
294 static int
295 eq_file_ptr (const PTR p1, const PTR p2)
297 struct ar_cache *arc1 = (struct ar_cache *) p1;
298 struct ar_cache *arc2 = (struct ar_cache *) p2;
299 return arc1->ptr == arc2->ptr;
302 /* Kind of stupid to call cons for each one, but we don't do too many. */
304 bfd_boolean
305 _bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt)
307 struct ar_cache *cache;
308 htab_t hash_table = bfd_ardata (arch_bfd)->cache;
310 /* If the hash table hasn't been created, create it. */
311 if (hash_table == NULL)
313 hash_table = htab_create_alloc (16, hash_file_ptr, eq_file_ptr,
314 NULL, calloc, free);
315 if (hash_table == NULL)
316 return FALSE;
317 bfd_ardata (arch_bfd)->cache = hash_table;
320 /* Insert new_elt into the hash table by filepos. */
321 cache = bfd_zalloc (arch_bfd, sizeof (struct ar_cache));
322 cache->ptr = filepos;
323 cache->arbfd = new_elt;
324 *htab_find_slot (hash_table, (const void *) cache, INSERT) = cache;
326 return TRUE;
329 /* The name begins with space. Hence the rest of the name is an index into
330 the string table. */
332 static char *
333 get_extended_arelt_filename (bfd *arch, const char *name)
335 unsigned long index = 0;
337 /* Should extract string so that I can guarantee not to overflow into
338 the next region, but I'm too lazy. */
339 errno = 0;
340 /* Skip first char, which is '/' in SVR4 or ' ' in some other variants. */
341 index = strtol (name + 1, NULL, 10);
342 if (errno != 0 || index >= bfd_ardata (arch)->extended_names_size)
344 bfd_set_error (bfd_error_malformed_archive);
345 return NULL;
348 return bfd_ardata (arch)->extended_names + index;
351 /* This functions reads an arch header and returns an areltdata pointer, or
352 NULL on error.
354 Presumes the file pointer is already in the right place (ie pointing
355 to the ar_hdr in the file). Moves the file pointer; on success it
356 should be pointing to the front of the file contents; on failure it
357 could have been moved arbitrarily. */
359 void *
360 _bfd_generic_read_ar_hdr (bfd *abfd)
362 return _bfd_generic_read_ar_hdr_mag (abfd, NULL);
365 /* Alpha ECOFF uses an optional different ARFMAG value, so we have a
366 variant of _bfd_generic_read_ar_hdr which accepts a magic string. */
368 void *
369 _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
371 struct ar_hdr hdr;
372 char *hdrp = (char *) &hdr;
373 size_t parsed_size;
374 struct areltdata *ared;
375 char *filename = NULL;
376 bfd_size_type namelen = 0;
377 bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
378 char *allocptr = 0;
380 if (bfd_bread (hdrp, sizeof (struct ar_hdr), abfd) != sizeof (struct ar_hdr))
382 if (bfd_get_error () != bfd_error_system_call)
383 bfd_set_error (bfd_error_no_more_archived_files);
384 return NULL;
386 if (strncmp (hdr.ar_fmag, ARFMAG, 2) != 0
387 && (mag == NULL
388 || strncmp (hdr.ar_fmag, mag, 2) != 0))
390 bfd_set_error (bfd_error_malformed_archive);
391 return NULL;
394 errno = 0;
395 parsed_size = strtol (hdr.ar_size, NULL, 10);
396 if (errno != 0)
398 bfd_set_error (bfd_error_malformed_archive);
399 return NULL;
402 /* Extract the filename from the archive - there are two ways to
403 specify an extended name table, either the first char of the
404 name is a space, or it's a slash. */
405 if ((hdr.ar_name[0] == '/'
406 || (hdr.ar_name[0] == ' '
407 && memchr (hdr.ar_name, '/', ar_maxnamelen (abfd)) == NULL))
408 && bfd_ardata (abfd)->extended_names != NULL)
410 filename = get_extended_arelt_filename (abfd, hdr.ar_name);
411 if (filename == NULL)
412 return NULL;
414 /* BSD4.4-style long filename.
415 Only implemented for reading, so far! */
416 else if (hdr.ar_name[0] == '#'
417 && hdr.ar_name[1] == '1'
418 && hdr.ar_name[2] == '/'
419 && ISDIGIT (hdr.ar_name[3]))
421 /* BSD-4.4 extended name */
422 namelen = atoi (&hdr.ar_name[3]);
423 allocsize += namelen + 1;
424 parsed_size -= namelen;
426 allocptr = bfd_zalloc (abfd, allocsize);
427 if (allocptr == NULL)
428 return NULL;
429 filename = (allocptr
430 + sizeof (struct areltdata)
431 + sizeof (struct ar_hdr));
432 if (bfd_bread (filename, namelen, abfd) != namelen)
434 if (bfd_get_error () != bfd_error_system_call)
435 bfd_set_error (bfd_error_no_more_archived_files);
436 return NULL;
438 filename[namelen] = '\0';
440 else
442 /* We judge the end of the name by looking for '/' or ' '.
443 Note: The SYSV format (terminated by '/') allows embedded
444 spaces, so only look for ' ' if we don't find '/'. */
446 char *e;
447 e = memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
448 if (e == NULL)
450 e = memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
451 if (e == NULL)
452 e = memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
455 if (e != NULL)
456 namelen = e - hdr.ar_name;
457 else
459 /* If we didn't find a termination character, then the name
460 must be the entire field. */
461 namelen = ar_maxnamelen (abfd);
464 allocsize += namelen + 1;
467 if (!allocptr)
469 allocptr = bfd_zalloc (abfd, allocsize);
470 if (allocptr == NULL)
471 return NULL;
474 ared = (struct areltdata *) allocptr;
476 ared->arch_header = allocptr + sizeof (struct areltdata);
477 memcpy (ared->arch_header, &hdr, sizeof (struct ar_hdr));
478 ared->parsed_size = parsed_size;
480 if (filename != NULL)
481 ared->filename = filename;
482 else
484 ared->filename = allocptr + (sizeof (struct areltdata) +
485 sizeof (struct ar_hdr));
486 if (namelen)
487 memcpy (ared->filename, hdr.ar_name, namelen);
488 ared->filename[namelen] = '\0';
491 return ared;
494 /* This is an internal function; it's mainly used when indexing
495 through the archive symbol table, but also used to get the next
496 element, since it handles the bookkeeping so nicely for us. */
498 bfd *
499 _bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos)
501 struct areltdata *new_areldata;
502 bfd *n_nfd;
504 if (archive->my_archive)
506 filepos += archive->origin;
507 archive = archive->my_archive;
510 n_nfd = _bfd_look_for_bfd_in_cache (archive, filepos);
511 if (n_nfd)
512 return n_nfd;
514 if (0 > bfd_seek (archive, filepos, SEEK_SET))
515 return NULL;
517 if ((new_areldata = _bfd_read_ar_hdr (archive)) == NULL)
518 return NULL;
520 n_nfd = _bfd_create_empty_archive_element_shell (archive);
521 if (n_nfd == NULL)
523 bfd_release (archive, new_areldata);
524 return NULL;
527 n_nfd->origin = bfd_tell (archive);
528 n_nfd->arelt_data = new_areldata;
529 n_nfd->filename = new_areldata->filename;
531 if (_bfd_add_bfd_to_archive_cache (archive, filepos, n_nfd))
532 return n_nfd;
534 /* Huh? */
535 bfd_release (archive, n_nfd);
536 bfd_release (archive, new_areldata);
537 return NULL;
540 /* Return the BFD which is referenced by the symbol in ABFD indexed by
541 INDEX. INDEX should have been returned by bfd_get_next_mapent. */
543 bfd *
544 _bfd_generic_get_elt_at_index (bfd *abfd, symindex index)
546 carsym *entry;
548 entry = bfd_ardata (abfd)->symdefs + index;
549 return _bfd_get_elt_at_filepos (abfd, entry->file_offset);
553 FUNCTION
554 bfd_openr_next_archived_file
556 SYNOPSIS
557 bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous);
559 DESCRIPTION
560 Provided a BFD, @var{archive}, containing an archive and NULL, open
561 an input BFD on the first contained element and returns that.
562 Subsequent calls should pass
563 the archive and the previous return value to return a created
564 BFD to the next contained element. NULL is returned when there
565 are no more.
568 bfd *
569 bfd_openr_next_archived_file (bfd *archive, bfd *last_file)
571 if ((bfd_get_format (archive) != bfd_archive) ||
572 (archive->direction == write_direction))
574 bfd_set_error (bfd_error_invalid_operation);
575 return NULL;
578 return BFD_SEND (archive,
579 openr_next_archived_file, (archive, last_file));
582 bfd *
583 bfd_generic_openr_next_archived_file (bfd *archive, bfd *last_file)
585 file_ptr filestart;
587 if (!last_file)
588 filestart = bfd_ardata (archive)->first_file_filepos;
589 else
591 unsigned int size = arelt_size (last_file);
592 filestart = last_file->origin + size;
593 if (archive->my_archive)
594 filestart -= archive->origin;
595 /* Pad to an even boundary...
596 Note that last_file->origin can be odd in the case of
597 BSD-4.4-style element with a long odd size. */
598 filestart += filestart % 2;
601 return _bfd_get_elt_at_filepos (archive, filestart);
604 const bfd_target *
605 bfd_generic_archive_p (bfd *abfd)
607 struct artdata *tdata_hold;
608 char armag[SARMAG + 1];
609 bfd_size_type amt;
611 if (bfd_bread (armag, SARMAG, abfd) != SARMAG)
613 if (bfd_get_error () != bfd_error_system_call)
614 bfd_set_error (bfd_error_wrong_format);
615 return NULL;
618 if (strncmp (armag, ARMAG, SARMAG) != 0 &&
619 strncmp (armag, ARMAGB, SARMAG) != 0)
620 return 0;
622 tdata_hold = bfd_ardata (abfd);
624 amt = sizeof (struct artdata);
625 bfd_ardata (abfd) = bfd_zalloc (abfd, amt);
626 if (bfd_ardata (abfd) == NULL)
628 bfd_ardata (abfd) = tdata_hold;
629 return NULL;
632 bfd_ardata (abfd)->first_file_filepos = SARMAG;
633 /* Cleared by bfd_zalloc above.
634 bfd_ardata (abfd)->cache = NULL;
635 bfd_ardata (abfd)->archive_head = NULL;
636 bfd_ardata (abfd)->symdefs = NULL;
637 bfd_ardata (abfd)->extended_names = NULL;
638 bfd_ardata (abfd)->extended_names_size = 0;
639 bfd_ardata (abfd)->tdata = NULL; */
641 if (!BFD_SEND (abfd, _bfd_slurp_armap, (abfd))
642 || !BFD_SEND (abfd, _bfd_slurp_extended_name_table, (abfd)))
644 if (bfd_get_error () != bfd_error_system_call)
645 bfd_set_error (bfd_error_wrong_format);
646 bfd_release (abfd, bfd_ardata (abfd));
647 bfd_ardata (abfd) = tdata_hold;
648 return NULL;
651 if (bfd_has_map (abfd))
653 bfd *first;
655 /* This archive has a map, so we may presume that the contents
656 are object files. Make sure that if the first file in the
657 archive can be recognized as an object file, it is for this
658 target. If not, assume that this is the wrong format. If
659 the first file is not an object file, somebody is doing
660 something weird, and we permit it so that ar -t will work.
662 This is done because any normal format will recognize any
663 normal archive, regardless of the format of the object files.
664 We do accept an empty archive. */
666 first = bfd_openr_next_archived_file (abfd, NULL);
667 if (first != NULL)
669 bfd_boolean fail;
671 first->target_defaulted = FALSE;
672 fail = FALSE;
673 if (bfd_check_format (first, bfd_object)
674 && first->xvec != abfd->xvec)
676 bfd_set_error (bfd_error_wrong_object_format);
677 bfd_ardata (abfd) = tdata_hold;
678 return NULL;
680 /* And we ought to close `first' here too. */
684 return abfd->xvec;
687 /* Some constants for a 32 bit BSD archive structure. We do not
688 support 64 bit archives presently; so far as I know, none actually
689 exist. Supporting them would require changing these constants, and
690 changing some H_GET_32 to H_GET_64. */
692 /* The size of an external symdef structure. */
693 #define BSD_SYMDEF_SIZE 8
695 /* The offset from the start of a symdef structure to the file offset. */
696 #define BSD_SYMDEF_OFFSET_SIZE 4
698 /* The size of the symdef count. */
699 #define BSD_SYMDEF_COUNT_SIZE 4
701 /* The size of the string count. */
702 #define BSD_STRING_COUNT_SIZE 4
704 /* Returns FALSE on error, TRUE otherwise. */
706 static bfd_boolean
707 do_slurp_bsd_armap (bfd *abfd)
709 struct areltdata *mapdata;
710 unsigned int counter;
711 bfd_byte *raw_armap, *rbase;
712 struct artdata *ardata = bfd_ardata (abfd);
713 char *stringbase;
714 bfd_size_type parsed_size, amt;
715 carsym *set;
717 mapdata = _bfd_read_ar_hdr (abfd);
718 if (mapdata == NULL)
719 return FALSE;
720 parsed_size = mapdata->parsed_size;
721 bfd_release (abfd, mapdata); /* Don't need it any more. */
723 raw_armap = bfd_zalloc (abfd, parsed_size);
724 if (raw_armap == NULL)
725 return FALSE;
727 if (bfd_bread (raw_armap, parsed_size, abfd) != parsed_size)
729 if (bfd_get_error () != bfd_error_system_call)
730 bfd_set_error (bfd_error_malformed_archive);
731 byebye:
732 bfd_release (abfd, raw_armap);
733 return FALSE;
736 ardata->symdef_count = H_GET_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE;
738 if (ardata->symdef_count * BSD_SYMDEF_SIZE >
739 parsed_size - BSD_SYMDEF_COUNT_SIZE)
741 /* Probably we're using the wrong byte ordering. */
742 bfd_set_error (bfd_error_wrong_format);
743 goto byebye;
746 ardata->cache = 0;
747 rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE;
748 stringbase = ((char *) rbase
749 + ardata->symdef_count * BSD_SYMDEF_SIZE
750 + BSD_STRING_COUNT_SIZE);
751 amt = ardata->symdef_count * sizeof (carsym);
752 ardata->symdefs = bfd_alloc (abfd, amt);
753 if (!ardata->symdefs)
754 return FALSE;
756 for (counter = 0, set = ardata->symdefs;
757 counter < ardata->symdef_count;
758 counter++, set++, rbase += BSD_SYMDEF_SIZE)
760 set->name = H_GET_32 (abfd, rbase) + stringbase;
761 set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
764 ardata->first_file_filepos = bfd_tell (abfd);
765 /* Pad to an even boundary if you have to. */
766 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
767 /* FIXME, we should provide some way to free raw_ardata when
768 we are done using the strings from it. For now, it seems
769 to be allocated on an objalloc anyway... */
770 bfd_has_map (abfd) = TRUE;
771 return TRUE;
774 /* Returns FALSE on error, TRUE otherwise. */
776 static bfd_boolean
777 do_slurp_coff_armap (bfd *abfd)
779 struct areltdata *mapdata;
780 int *raw_armap, *rawptr;
781 struct artdata *ardata = bfd_ardata (abfd);
782 char *stringbase;
783 bfd_size_type stringsize;
784 unsigned int parsed_size;
785 carsym *carsyms;
786 bfd_size_type nsymz; /* Number of symbols in armap. */
787 bfd_vma (*swap) (const void *);
788 char int_buf[sizeof (long)];
789 bfd_size_type carsym_size, ptrsize;
790 unsigned int i;
792 mapdata = _bfd_read_ar_hdr (abfd);
793 if (mapdata == NULL)
794 return FALSE;
795 parsed_size = mapdata->parsed_size;
796 bfd_release (abfd, mapdata); /* Don't need it any more. */
798 if (bfd_bread (int_buf, 4, abfd) != 4)
800 if (bfd_get_error () != bfd_error_system_call)
801 bfd_set_error (bfd_error_malformed_archive);
802 return FALSE;
804 /* It seems that all numeric information in a coff archive is always
805 in big endian format, nomatter the host or target. */
806 swap = bfd_getb32;
807 nsymz = bfd_getb32 (int_buf);
808 stringsize = parsed_size - (4 * nsymz) - 4;
810 /* ... except that some archive formats are broken, and it may be our
811 fault - the i960 little endian coff sometimes has big and sometimes
812 little, because our tools changed. Here's a horrible hack to clean
813 up the crap. */
815 if (stringsize > 0xfffff
816 && bfd_get_arch (abfd) == bfd_arch_i960
817 && bfd_get_flavour (abfd) == bfd_target_coff_flavour)
819 /* This looks dangerous, let's do it the other way around. */
820 nsymz = bfd_getl32 (int_buf);
821 stringsize = parsed_size - (4 * nsymz) - 4;
822 swap = bfd_getl32;
825 /* The coff armap must be read sequentially. So we construct a
826 bsd-style one in core all at once, for simplicity. */
828 if (nsymz > ~ (bfd_size_type) 0 / sizeof (carsym))
829 return FALSE;
831 carsym_size = (nsymz * sizeof (carsym));
832 ptrsize = (4 * nsymz);
834 if (carsym_size + stringsize + 1 <= carsym_size)
835 return FALSE;
837 ardata->symdefs = bfd_zalloc (abfd, carsym_size + stringsize + 1);
838 if (ardata->symdefs == NULL)
839 return FALSE;
840 carsyms = ardata->symdefs;
841 stringbase = ((char *) ardata->symdefs) + carsym_size;
843 /* Allocate and read in the raw offsets. */
844 raw_armap = bfd_alloc (abfd, ptrsize);
845 if (raw_armap == NULL)
846 goto release_symdefs;
847 if (bfd_bread (raw_armap, ptrsize, abfd) != ptrsize
848 || (bfd_bread (stringbase, stringsize, abfd) != stringsize))
850 if (bfd_get_error () != bfd_error_system_call)
851 bfd_set_error (bfd_error_malformed_archive);
852 goto release_raw_armap;
855 /* OK, build the carsyms. */
856 for (i = 0; i < nsymz; i++)
858 rawptr = raw_armap + i;
859 carsyms->file_offset = swap ((bfd_byte *) rawptr);
860 carsyms->name = stringbase;
861 stringbase += strlen (stringbase) + 1;
862 carsyms++;
864 *stringbase = 0;
866 ardata->symdef_count = nsymz;
867 ardata->first_file_filepos = bfd_tell (abfd);
868 /* Pad to an even boundary if you have to. */
869 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
871 bfd_has_map (abfd) = TRUE;
872 bfd_release (abfd, raw_armap);
874 /* Check for a second archive header (as used by PE). */
876 struct areltdata *tmp;
878 bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET);
879 tmp = _bfd_read_ar_hdr (abfd);
880 if (tmp != NULL)
882 if (tmp->arch_header[0] == '/'
883 && tmp->arch_header[1] == ' ')
885 ardata->first_file_filepos +=
886 (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1;
888 bfd_release (abfd, tmp);
892 return TRUE;
894 release_raw_armap:
895 bfd_release (abfd, raw_armap);
896 release_symdefs:
897 bfd_release (abfd, (ardata)->symdefs);
898 return FALSE;
901 /* This routine can handle either coff-style or bsd-style armaps.
902 Returns FALSE on error, TRUE otherwise */
904 bfd_boolean
905 bfd_slurp_armap (bfd *abfd)
907 char nextname[17];
908 int i = bfd_bread (nextname, 16, abfd);
910 if (i == 0)
911 return TRUE;
912 if (i != 16)
913 return FALSE;
915 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
916 return FALSE;
918 if (!strncmp (nextname, "__.SYMDEF ", 16)
919 || !strncmp (nextname, "__.SYMDEF/ ", 16)) /* old Linux archives */
920 return do_slurp_bsd_armap (abfd);
921 else if (!strncmp (nextname, "/ ", 16))
922 return do_slurp_coff_armap (abfd);
923 else if (!strncmp (nextname, "/SYM64/ ", 16))
925 /* 64bit ELF (Irix 6) archive. */
926 #ifdef BFD64
927 extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *);
928 return bfd_elf64_archive_slurp_armap (abfd);
929 #else
930 bfd_set_error (bfd_error_wrong_format);
931 return FALSE;
932 #endif
935 bfd_has_map (abfd) = FALSE;
936 return TRUE;
939 /* Returns FALSE on error, TRUE otherwise. */
940 /* Flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
941 header is in a slightly different order and the map name is '/'.
942 This flavour is used by hp300hpux. */
944 #define HPUX_SYMDEF_COUNT_SIZE 2
946 bfd_boolean
947 bfd_slurp_bsd_armap_f2 (bfd *abfd)
949 struct areltdata *mapdata;
950 char nextname[17];
951 unsigned int counter;
952 bfd_byte *raw_armap, *rbase;
953 struct artdata *ardata = bfd_ardata (abfd);
954 char *stringbase;
955 unsigned int stringsize;
956 bfd_size_type amt;
957 carsym *set;
958 int i = bfd_bread (nextname, 16, abfd);
960 if (i == 0)
961 return TRUE;
962 if (i != 16)
963 return FALSE;
965 /* The archive has at least 16 bytes in it. */
966 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
967 return FALSE;
969 if (!strncmp (nextname, "__.SYMDEF ", 16)
970 || !strncmp (nextname, "__.SYMDEF/ ", 16)) /* Old Linux archives. */
971 return do_slurp_bsd_armap (abfd);
973 if (strncmp (nextname, "/ ", 16))
975 bfd_has_map (abfd) = FALSE;
976 return TRUE;
979 mapdata = _bfd_read_ar_hdr (abfd);
980 if (mapdata == NULL)
981 return FALSE;
983 amt = mapdata->parsed_size;
984 raw_armap = bfd_zalloc (abfd, amt);
985 if (raw_armap == NULL)
987 byebye:
988 bfd_release (abfd, mapdata);
989 return FALSE;
992 if (bfd_bread (raw_armap, amt, abfd) != amt)
994 if (bfd_get_error () != bfd_error_system_call)
995 bfd_set_error (bfd_error_malformed_archive);
996 byebyebye:
997 bfd_release (abfd, raw_armap);
998 goto byebye;
1001 ardata->symdef_count = H_GET_16 (abfd, raw_armap);
1003 if (ardata->symdef_count * BSD_SYMDEF_SIZE
1004 > mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE)
1006 /* Probably we're using the wrong byte ordering. */
1007 bfd_set_error (bfd_error_wrong_format);
1008 goto byebyebye;
1011 ardata->cache = 0;
1013 stringsize = H_GET_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE);
1014 /* Skip sym count and string sz. */
1015 stringbase = ((char *) raw_armap
1016 + HPUX_SYMDEF_COUNT_SIZE
1017 + BSD_STRING_COUNT_SIZE);
1018 rbase = (bfd_byte *) stringbase + stringsize;
1019 amt = ardata->symdef_count * BSD_SYMDEF_SIZE;
1020 ardata->symdefs = bfd_alloc (abfd, amt);
1021 if (!ardata->symdefs)
1022 return FALSE;
1024 for (counter = 0, set = ardata->symdefs;
1025 counter < ardata->symdef_count;
1026 counter++, set++, rbase += BSD_SYMDEF_SIZE)
1028 set->name = H_GET_32 (abfd, rbase) + stringbase;
1029 set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
1032 ardata->first_file_filepos = bfd_tell (abfd);
1033 /* Pad to an even boundary if you have to. */
1034 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1035 /* FIXME, we should provide some way to free raw_ardata when
1036 we are done using the strings from it. For now, it seems
1037 to be allocated on an objalloc anyway... */
1038 bfd_has_map (abfd) = TRUE;
1039 return TRUE;
1042 /** Extended name table.
1044 Normally archives support only 14-character filenames.
1046 Intel has extended the format: longer names are stored in a special
1047 element (the first in the archive, or second if there is an armap);
1048 the name in the ar_hdr is replaced by <space><index into filename
1049 element>. Index is the P.R. of an int (decimal). Data General have
1050 extended the format by using the prefix // for the special element. */
1052 /* Returns FALSE on error, TRUE otherwise. */
1054 bfd_boolean
1055 _bfd_slurp_extended_name_table (bfd *abfd)
1057 char nextname[17];
1058 struct areltdata *namedata;
1059 bfd_size_type amt;
1061 /* FIXME: Formatting sucks here, and in case of failure of BFD_READ,
1062 we probably don't want to return TRUE. */
1063 bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET);
1064 if (bfd_bread (nextname, 16, abfd) == 16)
1066 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1067 return FALSE;
1069 if (strncmp (nextname, "ARFILENAMES/ ", 16) != 0 &&
1070 strncmp (nextname, "// ", 16) != 0)
1072 bfd_ardata (abfd)->extended_names = NULL;
1073 bfd_ardata (abfd)->extended_names_size = 0;
1074 return TRUE;
1077 namedata = _bfd_read_ar_hdr (abfd);
1078 if (namedata == NULL)
1079 return FALSE;
1081 amt = namedata->parsed_size;
1082 if (amt + 1 == 0)
1083 goto byebye;
1085 bfd_ardata (abfd)->extended_names_size = amt;
1086 bfd_ardata (abfd)->extended_names = bfd_zalloc (abfd, amt + 1);
1087 if (bfd_ardata (abfd)->extended_names == NULL)
1089 byebye:
1090 bfd_release (abfd, namedata);
1091 return FALSE;
1094 if (bfd_bread (bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
1096 if (bfd_get_error () != bfd_error_system_call)
1097 bfd_set_error (bfd_error_malformed_archive);
1098 bfd_release (abfd, (bfd_ardata (abfd)->extended_names));
1099 bfd_ardata (abfd)->extended_names = NULL;
1100 goto byebye;
1103 /* Since the archive is supposed to be printable if it contains
1104 text, the entries in the list are newline-padded, not null
1105 padded. In SVR4-style archives, the names also have a
1106 trailing '/'. DOS/NT created archive often have \ in them
1107 We'll fix all problems here.. */
1109 char *ext_names = bfd_ardata (abfd)->extended_names;
1110 char *temp = ext_names;
1111 char *limit = temp + namedata->parsed_size;
1112 for (; temp < limit; ++temp)
1114 if (*temp == '\012')
1115 temp[temp > ext_names && temp[-1] == '/' ? -1 : 0] = '\0';
1116 if (*temp == '\\')
1117 *temp = '/';
1119 *limit = '\0';
1122 /* Pad to an even boundary if you have to. */
1123 bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd);
1124 bfd_ardata (abfd)->first_file_filepos +=
1125 (bfd_ardata (abfd)->first_file_filepos) % 2;
1127 /* FIXME, we can't release namedata here because it was allocated
1128 below extended_names on the objalloc... */
1130 return TRUE;
1133 #ifdef VMS
1135 /* Return a copy of the stuff in the filename between any :]> and a
1136 semicolon. */
1138 static const char *
1139 normalize (bfd *abfd, const char *file)
1141 const char *first;
1142 const char *last;
1143 char *copy;
1145 first = file + strlen (file) - 1;
1146 last = first + 1;
1148 while (first != file)
1150 if (*first == ';')
1151 last = first;
1152 if (*first == ':' || *first == ']' || *first == '>')
1154 first++;
1155 break;
1157 first--;
1160 copy = bfd_alloc (abfd, last - first + 1);
1161 if (copy == NULL)
1162 return NULL;
1164 memcpy (copy, first, last - first);
1165 copy[last - first] = 0;
1167 return copy;
1170 #else
1171 static const char *
1172 normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file)
1174 const char *filename = strrchr (file, '/');
1176 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1178 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */
1179 char *bslash = strrchr (file, '\\');
1180 if (filename == NULL || (bslash != NULL && bslash > filename))
1181 filename = bslash;
1182 if (filename == NULL && file[0] != '\0' && file[1] == ':')
1183 filename = file + 1;
1185 #endif
1186 if (filename != NULL)
1187 filename++;
1188 else
1189 filename = file;
1190 return filename;
1192 #endif
1194 /* Build a BFD style extended name table. */
1196 bfd_boolean
1197 _bfd_archive_bsd_construct_extended_name_table (bfd *abfd,
1198 char **tabloc,
1199 bfd_size_type *tablen,
1200 const char **name)
1202 *name = "ARFILENAMES/";
1203 return _bfd_construct_extended_name_table (abfd, FALSE, tabloc, tablen);
1206 /* Build an SVR4 style extended name table. */
1208 bfd_boolean
1209 _bfd_archive_coff_construct_extended_name_table (bfd *abfd,
1210 char **tabloc,
1211 bfd_size_type *tablen,
1212 const char **name)
1214 *name = "//";
1215 return _bfd_construct_extended_name_table (abfd, TRUE, tabloc, tablen);
1218 /* Follows archive_head and produces an extended name table if
1219 necessary. Returns (in tabloc) a pointer to an extended name
1220 table, and in tablen the length of the table. If it makes an entry
1221 it clobbers the filename so that the element may be written without
1222 further massage. Returns TRUE if it ran successfully, FALSE if
1223 something went wrong. A successful return may still involve a
1224 zero-length tablen! */
1226 bfd_boolean
1227 _bfd_construct_extended_name_table (bfd *abfd,
1228 bfd_boolean trailing_slash,
1229 char **tabloc,
1230 bfd_size_type *tablen)
1232 unsigned int maxname = abfd->xvec->ar_max_namelen;
1233 bfd_size_type total_namelen = 0;
1234 bfd *current;
1235 char *strptr;
1237 *tablen = 0;
1239 /* Figure out how long the table should be. */
1240 for (current = abfd->archive_head; current != NULL; current = current->next)
1242 const char *normal;
1243 unsigned int thislen;
1245 normal = normalize (current, current->filename);
1246 if (normal == NULL)
1247 return FALSE;
1249 thislen = strlen (normal);
1251 if (thislen > maxname
1252 && (bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1253 thislen = maxname;
1255 if (thislen > maxname)
1257 /* Add one to leave room for \n. */
1258 total_namelen += thislen + 1;
1259 if (trailing_slash)
1261 /* Leave room for trailing slash. */
1262 ++total_namelen;
1265 else
1267 struct ar_hdr *hdr = arch_hdr (current);
1268 if (strncmp (normal, hdr->ar_name, thislen) != 0
1269 || (thislen < sizeof hdr->ar_name
1270 && hdr->ar_name[thislen] != ar_padchar (current)))
1272 /* Must have been using extended format even though it
1273 didn't need to. Fix it to use normal format. */
1274 memcpy (hdr->ar_name, normal, thislen);
1275 if (thislen < maxname
1276 || (thislen == maxname && thislen < sizeof hdr->ar_name))
1277 hdr->ar_name[thislen] = ar_padchar (current);
1282 if (total_namelen == 0)
1283 return TRUE;
1285 *tabloc = bfd_zalloc (abfd, total_namelen);
1286 if (*tabloc == NULL)
1287 return FALSE;
1289 *tablen = total_namelen;
1290 strptr = *tabloc;
1292 for (current = abfd->archive_head; current != NULL; current =
1293 current->next)
1295 const char *normal;
1296 unsigned int thislen;
1298 normal = normalize (current, current->filename);
1299 if (normal == NULL)
1300 return FALSE;
1302 thislen = strlen (normal);
1303 if (thislen > maxname)
1305 /* Works for now; may need to be re-engineered if we
1306 encounter an oddball archive format and want to
1307 generalise this hack. */
1308 struct ar_hdr *hdr = arch_hdr (current);
1309 strcpy (strptr, normal);
1310 if (! trailing_slash)
1311 strptr[thislen] = '\012';
1312 else
1314 strptr[thislen] = '/';
1315 strptr[thislen + 1] = '\012';
1317 hdr->ar_name[0] = ar_padchar (current);
1318 _bfd_ar_spacepad (hdr->ar_name + 1, maxname - 1, "%-ld",
1319 strptr - *tabloc);
1320 strptr += thislen + 1;
1321 if (trailing_slash)
1322 ++strptr;
1326 return TRUE;
1329 /* A couple of functions for creating ar_hdrs. */
1331 #ifdef HPUX_LARGE_AR_IDS
1332 /* Function to encode large UID/GID values according to HP. */
1334 static void
1335 hpux_uid_gid_encode (char str[6], long int id)
1337 int cnt;
1339 str[5] = '@' + (id & 3);
1340 id >>= 2;
1342 for (cnt = 4; cnt >= 0; ++cnt, id >>= 6)
1343 str[cnt] = ' ' + (id & 0x3f);
1345 #endif /* HPUX_LARGE_AR_IDS */
1347 #ifndef HAVE_GETUID
1348 #define getuid() 0
1349 #endif
1351 #ifndef HAVE_GETGID
1352 #define getgid() 0
1353 #endif
1355 /* Takes a filename, returns an arelt_data for it, or NULL if it can't
1356 make one. The filename must refer to a filename in the filesystem.
1357 The filename field of the ar_hdr will NOT be initialized. If member
1358 is set, and it's an in-memory bfd, we fake it. */
1360 static struct areltdata *
1361 bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
1363 struct stat status;
1364 struct areltdata *ared;
1365 struct ar_hdr *hdr;
1366 bfd_size_type amt;
1368 if (member && (member->flags & BFD_IN_MEMORY) != 0)
1370 /* Assume we just "made" the member, and fake it. */
1371 struct bfd_in_memory *bim = member->iostream;
1372 time (&status.st_mtime);
1373 status.st_uid = getuid ();
1374 status.st_gid = getgid ();
1375 status.st_mode = 0644;
1376 status.st_size = bim->size;
1378 else if (stat (filename, &status) != 0)
1380 bfd_set_error (bfd_error_system_call);
1381 return NULL;
1384 amt = sizeof (struct ar_hdr) + sizeof (struct areltdata);
1385 ared = bfd_zalloc (abfd, amt);
1386 if (ared == NULL)
1387 return NULL;
1388 hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));
1390 /* ar headers are space padded, not null padded! */
1391 memset (hdr, ' ', sizeof (struct ar_hdr));
1393 _bfd_ar_spacepad (hdr->ar_date, sizeof (hdr->ar_date), "%-12ld",
1394 status.st_mtime);
1395 #ifdef HPUX_LARGE_AR_IDS
1396 /* HP has a very "special" way to handle UID/GID's with numeric values
1397 > 99999. */
1398 if (status.st_uid > 99999)
1399 hpux_uid_gid_encode (hdr->ar_uid, (long) status.st_uid);
1400 else
1401 #endif
1402 _bfd_ar_spacepad (hdr->ar_uid, sizeof (hdr->ar_uid), "%ld",
1403 status.st_uid);
1404 #ifdef HPUX_LARGE_AR_IDS
1405 /* HP has a very "special" way to handle UID/GID's with numeric values
1406 > 99999. */
1407 if (status.st_gid > 99999)
1408 hpux_uid_gid_encode (hdr->ar_gid, (long) status.st_gid);
1409 else
1410 #endif
1411 _bfd_ar_spacepad (hdr->ar_gid, sizeof (hdr->ar_gid), "%ld",
1412 status.st_gid);
1413 _bfd_ar_spacepad (hdr->ar_mode, sizeof (hdr->ar_mode), "%-8lo",
1414 status.st_mode);
1415 _bfd_ar_spacepad (hdr->ar_size, sizeof (hdr->ar_size), "%-10ld",
1416 status.st_size);
1417 memcpy (hdr->ar_fmag, ARFMAG, 2);
1418 ared->parsed_size = status.st_size;
1419 ared->arch_header = (char *) hdr;
1421 return ared;
1424 /* This is magic required by the "ar" program. Since it's
1425 undocumented, it's undocumented. You may think that it would take
1426 a strong stomach to write this, and it does, but it takes even a
1427 stronger stomach to try to code around such a thing! */
1429 struct ar_hdr *bfd_special_undocumented_glue (bfd *, const char *);
1431 struct ar_hdr *
1432 bfd_special_undocumented_glue (bfd *abfd, const char *filename)
1434 struct areltdata *ar_elt = bfd_ar_hdr_from_filesystem (abfd, filename, 0);
1435 if (ar_elt == NULL)
1436 return NULL;
1437 return (struct ar_hdr *) ar_elt->arch_header;
1440 /* Analogous to stat call. */
1443 bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
1445 struct ar_hdr *hdr;
1446 char *aloser;
1448 if (abfd->arelt_data == NULL)
1450 bfd_set_error (bfd_error_invalid_operation);
1451 return -1;
1454 hdr = arch_hdr (abfd);
1456 #define foo(arelt, stelt, size) \
1457 buf->stelt = strtol (hdr->arelt, &aloser, size); \
1458 if (aloser == hdr->arelt) \
1459 return -1;
1461 /* Some platforms support special notations for large IDs. */
1462 #ifdef HPUX_LARGE_AR_IDS
1463 # define foo2(arelt, stelt, size) \
1464 if (hdr->arelt[5] == ' ') \
1466 foo (arelt, stelt, size); \
1468 else \
1470 int cnt; \
1471 for (buf->stelt = cnt = 0; cnt < 5; ++cnt) \
1473 if (hdr->arelt[cnt] < ' ' || hdr->arelt[cnt] > ' ' + 0x3f) \
1474 return -1; \
1475 buf->stelt <<= 6; \
1476 buf->stelt += hdr->arelt[cnt] - ' '; \
1478 if (hdr->arelt[5] < '@' || hdr->arelt[5] > '@' + 3) \
1479 return -1; \
1480 buf->stelt <<= 2; \
1481 buf->stelt += hdr->arelt[5] - '@'; \
1483 #else
1484 # define foo2(arelt, stelt, size) foo (arelt, stelt, size)
1485 #endif
1487 foo (ar_date, st_mtime, 10);
1488 foo2 (ar_uid, st_uid, 10);
1489 foo2 (ar_gid, st_gid, 10);
1490 foo (ar_mode, st_mode, 8);
1492 buf->st_size = arch_eltdata (abfd)->parsed_size;
1494 return 0;
1497 void
1498 bfd_dont_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1500 /* FIXME: This interacts unpleasantly with ar's quick-append option.
1501 Fortunately ic960 users will never use that option. Fixing this
1502 is very hard; fortunately I know how to do it and will do so once
1503 intel's release is out the door. */
1505 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1506 size_t length;
1507 const char *filename;
1508 size_t maxlen = ar_maxnamelen (abfd);
1510 if ((bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1512 bfd_bsd_truncate_arname (abfd, pathname, arhdr);
1513 return;
1516 filename = normalize (abfd, pathname);
1517 if (filename == NULL)
1519 /* FIXME */
1520 abort ();
1523 length = strlen (filename);
1525 if (length <= maxlen)
1526 memcpy (hdr->ar_name, filename, length);
1528 /* Add the padding character if there is room for it. */
1529 if (length < maxlen
1530 || (length == maxlen && length < sizeof hdr->ar_name))
1531 (hdr->ar_name)[length] = ar_padchar (abfd);
1534 void
1535 bfd_bsd_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1537 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1538 size_t length;
1539 const char *filename = strrchr (pathname, '/');
1540 size_t maxlen = ar_maxnamelen (abfd);
1542 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1544 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */
1545 char *bslash = strrchr (pathname, '\\');
1546 if (filename == NULL || (bslash != NULL && bslash > filename))
1547 filename = bslash;
1548 if (filename == NULL && pathname[0] != '\0' && pathname[1] == ':')
1549 filename = pathname + 1;
1551 #endif
1553 if (filename == NULL)
1554 filename = pathname;
1555 else
1556 ++filename;
1558 length = strlen (filename);
1560 if (length <= maxlen)
1561 memcpy (hdr->ar_name, filename, length);
1562 else
1564 /* pathname: meet procrustes */
1565 memcpy (hdr->ar_name, filename, maxlen);
1566 length = maxlen;
1569 if (length < maxlen)
1570 (hdr->ar_name)[length] = ar_padchar (abfd);
1573 /* Store name into ar header. Truncates the name to fit.
1574 1> strip pathname to be just the basename.
1575 2> if it's short enuf to fit, stuff it in.
1576 3> If it doesn't end with .o, truncate it to fit
1577 4> truncate it before the .o, append .o, stuff THAT in. */
1579 /* This is what gnu ar does. It's better but incompatible with the
1580 bsd ar. */
1582 void
1583 bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1585 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1586 size_t length;
1587 const char *filename = strrchr (pathname, '/');
1588 size_t maxlen = ar_maxnamelen (abfd);
1590 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1592 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */
1593 char *bslash = strrchr (pathname, '\\');
1594 if (filename == NULL || (bslash != NULL && bslash > filename))
1595 filename = bslash;
1596 if (filename == NULL && pathname[0] != '\0' && pathname[1] == ':')
1597 filename = pathname + 1;
1599 #endif
1601 if (filename == NULL)
1602 filename = pathname;
1603 else
1604 ++filename;
1606 length = strlen (filename);
1608 if (length <= maxlen)
1609 memcpy (hdr->ar_name, filename, length);
1610 else
1611 { /* pathname: meet procrustes */
1612 memcpy (hdr->ar_name, filename, maxlen);
1613 if ((filename[length - 2] == '.') && (filename[length - 1] == 'o'))
1615 hdr->ar_name[maxlen - 2] = '.';
1616 hdr->ar_name[maxlen - 1] = 'o';
1618 length = maxlen;
1621 if (length < 16)
1622 (hdr->ar_name)[length] = ar_padchar (abfd);
1625 /* The BFD is open for write and has its format set to bfd_archive. */
1627 bfd_boolean
1628 _bfd_write_archive_contents (bfd *arch)
1630 bfd *current;
1631 char *etable = NULL;
1632 bfd_size_type elength = 0;
1633 const char *ename = NULL;
1634 bfd_boolean makemap = bfd_has_map (arch);
1635 /* If no .o's, don't bother to make a map. */
1636 bfd_boolean hasobjects = FALSE;
1637 bfd_size_type wrote;
1638 int tries;
1640 /* Verify the viability of all entries; if any of them live in the
1641 filesystem (as opposed to living in an archive open for input)
1642 then construct a fresh ar_hdr for them. */
1643 for (current = arch->archive_head; current; current = current->next)
1645 /* This check is checking the bfds for the objects we're reading
1646 from (which are usually either an object file or archive on
1647 disk), not the archive entries we're writing to. We don't
1648 actually create bfds for the archive members, we just copy
1649 them byte-wise when we write out the archive. */
1650 if (bfd_write_p (current))
1652 bfd_set_error (bfd_error_invalid_operation);
1653 return FALSE;
1655 if (!current->arelt_data)
1657 current->arelt_data =
1658 bfd_ar_hdr_from_filesystem (arch, current->filename, current);
1659 if (!current->arelt_data)
1660 return FALSE;
1662 /* Put in the file name. */
1663 BFD_SEND (arch, _bfd_truncate_arname,
1664 (arch, current->filename, (char *) arch_hdr (current)));
1667 if (makemap && ! hasobjects)
1668 { /* Don't bother if we won't make a map! */
1669 if ((bfd_check_format (current, bfd_object)))
1670 hasobjects = TRUE;
1674 if (!BFD_SEND (arch, _bfd_construct_extended_name_table,
1675 (arch, &etable, &elength, &ename)))
1676 return FALSE;
1678 if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0)
1679 return FALSE;
1680 wrote = bfd_bwrite (ARMAG, SARMAG, arch);
1681 if (wrote != SARMAG)
1682 return FALSE;
1684 if (makemap && hasobjects)
1686 if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength))
1687 return FALSE;
1690 if (elength != 0)
1692 struct ar_hdr hdr;
1694 memset (&hdr, ' ', sizeof (struct ar_hdr));
1695 memcpy (hdr.ar_name, ename, strlen (ename));
1696 /* Round size up to even number in archive header. */
1697 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld",
1698 (elength + 1) & ~(bfd_size_type) 1);
1699 memcpy (hdr.ar_fmag, ARFMAG, 2);
1700 if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
1701 != sizeof (struct ar_hdr))
1702 || bfd_bwrite (etable, elength, arch) != elength)
1703 return FALSE;
1704 if ((elength % 2) == 1)
1706 if (bfd_bwrite ("\012", 1, arch) != 1)
1707 return FALSE;
1711 for (current = arch->archive_head; current; current = current->next)
1713 char buffer[DEFAULT_BUFFERSIZE];
1714 unsigned int remaining = arelt_size (current);
1715 struct ar_hdr *hdr = arch_hdr (current);
1717 /* Write ar header. */
1718 if (bfd_bwrite (hdr, sizeof (*hdr), arch)
1719 != sizeof (*hdr))
1720 return FALSE;
1721 if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
1722 return FALSE;
1723 while (remaining)
1725 unsigned int amt = DEFAULT_BUFFERSIZE;
1726 if (amt > remaining)
1727 amt = remaining;
1728 errno = 0;
1729 if (bfd_bread (buffer, amt, current) != amt)
1731 if (bfd_get_error () != bfd_error_system_call)
1732 bfd_set_error (bfd_error_malformed_archive);
1733 return FALSE;
1735 if (bfd_bwrite (buffer, amt, arch) != amt)
1736 return FALSE;
1737 remaining -= amt;
1739 if ((arelt_size (current) % 2) == 1)
1741 if (bfd_bwrite ("\012", 1, arch) != 1)
1742 return FALSE;
1746 if (makemap && hasobjects)
1748 /* Verify the timestamp in the archive file. If it would not be
1749 accepted by the linker, rewrite it until it would be. If
1750 anything odd happens, break out and just return. (The
1751 Berkeley linker checks the timestamp and refuses to read the
1752 table-of-contents if it is >60 seconds less than the file's
1753 modified-time. That painful hack requires this painful hack. */
1754 tries = 1;
1757 if (bfd_update_armap_timestamp (arch))
1758 break;
1759 (*_bfd_error_handler)
1760 (_("Warning: writing archive was slow: rewriting timestamp\n"));
1762 while (++tries < 6);
1765 return TRUE;
1768 /* Note that the namidx for the first symbol is 0. */
1770 bfd_boolean
1771 _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
1773 char *first_name = NULL;
1774 bfd *current;
1775 file_ptr elt_no = 0;
1776 struct orl *map = NULL;
1777 unsigned int orl_max = 1024; /* Fine initial default. */
1778 unsigned int orl_count = 0;
1779 int stridx = 0;
1780 asymbol **syms = NULL;
1781 long syms_max = 0;
1782 bfd_boolean ret;
1783 bfd_size_type amt;
1785 /* Dunno if this is the best place for this info... */
1786 if (elength != 0)
1787 elength += sizeof (struct ar_hdr);
1788 elength += elength % 2;
1790 amt = orl_max * sizeof (struct orl);
1791 map = bfd_malloc (amt);
1792 if (map == NULL)
1793 goto error_return;
1795 /* We put the symbol names on the arch objalloc, and then discard
1796 them when done. */
1797 first_name = bfd_alloc (arch, 1);
1798 if (first_name == NULL)
1799 goto error_return;
1801 /* Drop all the files called __.SYMDEF, we're going to make our own. */
1802 while (arch->archive_head &&
1803 strcmp (arch->archive_head->filename, "__.SYMDEF") == 0)
1804 arch->archive_head = arch->archive_head->next;
1806 /* Map over each element. */
1807 for (current = arch->archive_head;
1808 current != NULL;
1809 current = current->next, elt_no++)
1811 if (bfd_check_format (current, bfd_object)
1812 && (bfd_get_file_flags (current) & HAS_SYMS) != 0)
1814 long storage;
1815 long symcount;
1816 long src_count;
1818 storage = bfd_get_symtab_upper_bound (current);
1819 if (storage < 0)
1820 goto error_return;
1822 if (storage != 0)
1824 if (storage > syms_max)
1826 if (syms_max > 0)
1827 free (syms);
1828 syms_max = storage;
1829 syms = bfd_malloc (syms_max);
1830 if (syms == NULL)
1831 goto error_return;
1833 symcount = bfd_canonicalize_symtab (current, syms);
1834 if (symcount < 0)
1835 goto error_return;
1837 /* Now map over all the symbols, picking out the ones we
1838 want. */
1839 for (src_count = 0; src_count < symcount; src_count++)
1841 flagword flags = (syms[src_count])->flags;
1842 asection *sec = syms[src_count]->section;
1844 if ((flags & BSF_GLOBAL ||
1845 flags & BSF_WEAK ||
1846 flags & BSF_INDIRECT ||
1847 bfd_is_com_section (sec))
1848 && ! bfd_is_und_section (sec))
1850 bfd_size_type namelen;
1851 struct orl *new_map;
1853 /* This symbol will go into the archive header. */
1854 if (orl_count == orl_max)
1856 orl_max *= 2;
1857 amt = orl_max * sizeof (struct orl);
1858 new_map = bfd_realloc (map, amt);
1859 if (new_map == NULL)
1860 goto error_return;
1862 map = new_map;
1865 namelen = strlen (syms[src_count]->name);
1866 amt = sizeof (char *);
1867 map[orl_count].name = bfd_alloc (arch, amt);
1868 if (map[orl_count].name == NULL)
1869 goto error_return;
1870 *(map[orl_count].name) = bfd_alloc (arch, namelen + 1);
1871 if (*(map[orl_count].name) == NULL)
1872 goto error_return;
1873 strcpy (*(map[orl_count].name), syms[src_count]->name);
1874 map[orl_count].u.abfd = current;
1875 map[orl_count].namidx = stridx;
1877 stridx += namelen + 1;
1878 ++orl_count;
1883 /* Now ask the BFD to free up any cached information, so we
1884 don't fill all of memory with symbol tables. */
1885 if (! bfd_free_cached_info (current))
1886 goto error_return;
1890 /* OK, now we have collected all the data, let's write them out. */
1891 ret = BFD_SEND (arch, write_armap,
1892 (arch, elength, map, orl_count, stridx));
1894 if (syms_max > 0)
1895 free (syms);
1896 if (map != NULL)
1897 free (map);
1898 if (first_name != NULL)
1899 bfd_release (arch, first_name);
1901 return ret;
1903 error_return:
1904 if (syms_max > 0)
1905 free (syms);
1906 if (map != NULL)
1907 free (map);
1908 if (first_name != NULL)
1909 bfd_release (arch, first_name);
1911 return FALSE;
1914 bfd_boolean
1915 bsd_write_armap (bfd *arch,
1916 unsigned int elength,
1917 struct orl *map,
1918 unsigned int orl_count,
1919 int stridx)
1921 int padit = stridx & 1;
1922 unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE;
1923 unsigned int stringsize = stridx + padit;
1924 /* Include 8 bytes to store ranlibsize and stringsize in output. */
1925 unsigned int mapsize = ranlibsize + stringsize + 8;
1926 file_ptr firstreal;
1927 bfd *current = arch->archive_head;
1928 bfd *last_elt = current; /* Last element arch seen. */
1929 bfd_byte temp[4];
1930 unsigned int count;
1931 struct ar_hdr hdr;
1932 struct stat statbuf;
1934 firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
1936 stat (arch->filename, &statbuf);
1937 memset (&hdr, ' ', sizeof (struct ar_hdr));
1938 memcpy (hdr.ar_name, RANLIBMAG, strlen (RANLIBMAG));
1939 /* Remember the timestamp, to keep it holy. But fudge it a little. */
1940 bfd_ardata (arch)->armap_timestamp = statbuf.st_mtime + ARMAP_TIME_OFFSET;
1941 bfd_ardata (arch)->armap_datepos = (SARMAG
1942 + offsetof (struct ar_hdr, ar_date[0]));
1943 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
1944 bfd_ardata (arch)->armap_timestamp);
1945 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", getuid ());
1946 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", getgid ());
1947 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld", mapsize);
1948 memcpy (hdr.ar_fmag, ARFMAG, 2);
1949 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
1950 != sizeof (struct ar_hdr))
1951 return FALSE;
1952 H_PUT_32 (arch, ranlibsize, temp);
1953 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
1954 return FALSE;
1956 for (count = 0; count < orl_count; count++)
1958 bfd_byte buf[BSD_SYMDEF_SIZE];
1960 if (map[count].u.abfd != last_elt)
1964 firstreal += arelt_size (current) + sizeof (struct ar_hdr);
1965 firstreal += firstreal % 2;
1966 current = current->next;
1968 while (current != map[count].u.abfd);
1971 last_elt = current;
1972 H_PUT_32 (arch, map[count].namidx, buf);
1973 H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE);
1974 if (bfd_bwrite (buf, BSD_SYMDEF_SIZE, arch)
1975 != BSD_SYMDEF_SIZE)
1976 return FALSE;
1979 /* Now write the strings themselves. */
1980 H_PUT_32 (arch, stringsize, temp);
1981 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
1982 return FALSE;
1983 for (count = 0; count < orl_count; count++)
1985 size_t len = strlen (*map[count].name) + 1;
1987 if (bfd_bwrite (*map[count].name, len, arch) != len)
1988 return FALSE;
1991 /* The spec sez this should be a newline. But in order to be
1992 bug-compatible for sun's ar we use a null. */
1993 if (padit)
1995 if (bfd_bwrite ("", 1, arch) != 1)
1996 return FALSE;
1999 return TRUE;
2002 /* At the end of archive file handling, update the timestamp in the
2003 file, so the linker will accept it.
2005 Return TRUE if the timestamp was OK, or an unusual problem happened.
2006 Return FALSE if we updated the timestamp. */
2008 bfd_boolean
2009 _bfd_archive_bsd_update_armap_timestamp (bfd *arch)
2011 struct stat archstat;
2012 struct ar_hdr hdr;
2014 /* Flush writes, get last-write timestamp from file, and compare it
2015 to the timestamp IN the file. */
2016 bfd_flush (arch);
2017 if (bfd_stat (arch, &archstat) == -1)
2019 bfd_perror (_("Reading archive file mod timestamp"));
2021 /* Can't read mod time for some reason. */
2022 return TRUE;
2024 if (archstat.st_mtime <= bfd_ardata (arch)->armap_timestamp)
2025 /* OK by the linker's rules. */
2026 return TRUE;
2028 /* Update the timestamp. */
2029 bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET;
2031 /* Prepare an ASCII version suitable for writing. */
2032 memset (hdr.ar_date, ' ', sizeof (hdr.ar_date));
2033 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2034 bfd_ardata (arch)->armap_timestamp);
2036 /* Write it into the file. */
2037 bfd_ardata (arch)->armap_datepos = (SARMAG
2038 + offsetof (struct ar_hdr, ar_date[0]));
2039 if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0
2040 || (bfd_bwrite (hdr.ar_date, sizeof (hdr.ar_date), arch)
2041 != sizeof (hdr.ar_date)))
2043 bfd_perror (_("Writing updated armap timestamp"));
2045 /* Some error while writing. */
2046 return TRUE;
2049 /* We updated the timestamp successfully. */
2050 return FALSE;
2053 /* A coff armap looks like :
2054 lARMAG
2055 struct ar_hdr with name = '/'
2056 number of symbols
2057 offset of file for symbol 0
2058 offset of file for symbol 1
2060 offset of file for symbol n-1
2061 symbol name 0
2062 symbol name 1
2064 symbol name n-1 */
2066 bfd_boolean
2067 coff_write_armap (bfd *arch,
2068 unsigned int elength,
2069 struct orl *map,
2070 unsigned int symbol_count,
2071 int stridx)
2073 /* The size of the ranlib is the number of exported symbols in the
2074 archive * the number of bytes in an int, + an int for the count. */
2075 unsigned int ranlibsize = (symbol_count * 4) + 4;
2076 unsigned int stringsize = stridx;
2077 unsigned int mapsize = stringsize + ranlibsize;
2078 unsigned int archive_member_file_ptr;
2079 bfd *current = arch->archive_head;
2080 unsigned int count;
2081 struct ar_hdr hdr;
2082 int padit = mapsize & 1;
2084 if (padit)
2085 mapsize++;
2087 /* Work out where the first object file will go in the archive. */
2088 archive_member_file_ptr = (mapsize
2089 + elength
2090 + sizeof (struct ar_hdr)
2091 + SARMAG);
2093 memset (&hdr, ' ', sizeof (struct ar_hdr));
2094 hdr.ar_name[0] = '/';
2095 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld",
2096 mapsize);
2097 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2098 time (NULL));
2099 /* This, at least, is what Intel coff sets the values to. */
2100 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", 0);
2101 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", 0);
2102 _bfd_ar_spacepad (hdr.ar_mode, sizeof (hdr.ar_mode), "%-7lo", 0);
2103 memcpy (hdr.ar_fmag, ARFMAG, 2);
2105 /* Write the ar header for this item and the number of symbols. */
2106 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2107 != sizeof (struct ar_hdr))
2108 return FALSE;
2110 if (!bfd_write_bigendian_4byte_int (arch, symbol_count))
2111 return FALSE;
2113 /* Two passes, first write the file offsets for each symbol -
2114 remembering that each offset is on a two byte boundary. */
2116 /* Write out the file offset for the file associated with each
2117 symbol, and remember to keep the offsets padded out. */
2119 current = arch->archive_head;
2120 count = 0;
2121 while (current != NULL && count < symbol_count)
2123 /* For each symbol which is used defined in this object, write
2124 out the object file's address in the archive. */
2126 while (count < symbol_count && map[count].u.abfd == current)
2128 if (!bfd_write_bigendian_4byte_int (arch, archive_member_file_ptr))
2129 return FALSE;
2130 count++;
2132 /* Add size of this archive entry. */
2133 archive_member_file_ptr += arelt_size (current) + sizeof (struct ar_hdr);
2134 /* Remember aboout the even alignment. */
2135 archive_member_file_ptr += archive_member_file_ptr % 2;
2136 current = current->next;
2139 /* Now write the strings themselves. */
2140 for (count = 0; count < symbol_count; count++)
2142 size_t len = strlen (*map[count].name) + 1;
2144 if (bfd_bwrite (*map[count].name, len, arch) != len)
2145 return FALSE;
2148 /* The spec sez this should be a newline. But in order to be
2149 bug-compatible for arc960 we use a null. */
2150 if (padit)
2152 if (bfd_bwrite ("", 1, arch) != 1)
2153 return FALSE;
2156 return TRUE;