gas/
[binutils.git] / bfd / archive.c
blob22261ac4006a2e5b7efa2018f94601fde4d34224
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
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 first->target_defaulted = FALSE;
670 if (bfd_check_format (first, bfd_object)
671 && first->xvec != abfd->xvec)
673 bfd_set_error (bfd_error_wrong_object_format);
674 bfd_ardata (abfd) = tdata_hold;
675 return NULL;
677 /* And we ought to close `first' here too. */
681 return abfd->xvec;
684 /* Some constants for a 32 bit BSD archive structure. We do not
685 support 64 bit archives presently; so far as I know, none actually
686 exist. Supporting them would require changing these constants, and
687 changing some H_GET_32 to H_GET_64. */
689 /* The size of an external symdef structure. */
690 #define BSD_SYMDEF_SIZE 8
692 /* The offset from the start of a symdef structure to the file offset. */
693 #define BSD_SYMDEF_OFFSET_SIZE 4
695 /* The size of the symdef count. */
696 #define BSD_SYMDEF_COUNT_SIZE 4
698 /* The size of the string count. */
699 #define BSD_STRING_COUNT_SIZE 4
701 /* Returns FALSE on error, TRUE otherwise. */
703 static bfd_boolean
704 do_slurp_bsd_armap (bfd *abfd)
706 struct areltdata *mapdata;
707 unsigned int counter;
708 bfd_byte *raw_armap, *rbase;
709 struct artdata *ardata = bfd_ardata (abfd);
710 char *stringbase;
711 bfd_size_type parsed_size, amt;
712 carsym *set;
714 mapdata = _bfd_read_ar_hdr (abfd);
715 if (mapdata == NULL)
716 return FALSE;
717 parsed_size = mapdata->parsed_size;
718 bfd_release (abfd, mapdata); /* Don't need it any more. */
720 raw_armap = bfd_zalloc (abfd, parsed_size);
721 if (raw_armap == NULL)
722 return FALSE;
724 if (bfd_bread (raw_armap, parsed_size, abfd) != parsed_size)
726 if (bfd_get_error () != bfd_error_system_call)
727 bfd_set_error (bfd_error_malformed_archive);
728 byebye:
729 bfd_release (abfd, raw_armap);
730 return FALSE;
733 ardata->symdef_count = H_GET_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE;
735 if (ardata->symdef_count * BSD_SYMDEF_SIZE >
736 parsed_size - BSD_SYMDEF_COUNT_SIZE)
738 /* Probably we're using the wrong byte ordering. */
739 bfd_set_error (bfd_error_wrong_format);
740 goto byebye;
743 ardata->cache = 0;
744 rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE;
745 stringbase = ((char *) rbase
746 + ardata->symdef_count * BSD_SYMDEF_SIZE
747 + BSD_STRING_COUNT_SIZE);
748 amt = ardata->symdef_count * sizeof (carsym);
749 ardata->symdefs = bfd_alloc (abfd, amt);
750 if (!ardata->symdefs)
751 return FALSE;
753 for (counter = 0, set = ardata->symdefs;
754 counter < ardata->symdef_count;
755 counter++, set++, rbase += BSD_SYMDEF_SIZE)
757 set->name = H_GET_32 (abfd, rbase) + stringbase;
758 set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
761 ardata->first_file_filepos = bfd_tell (abfd);
762 /* Pad to an even boundary if you have to. */
763 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
764 /* FIXME, we should provide some way to free raw_ardata when
765 we are done using the strings from it. For now, it seems
766 to be allocated on an objalloc anyway... */
767 bfd_has_map (abfd) = TRUE;
768 return TRUE;
771 /* Returns FALSE on error, TRUE otherwise. */
773 static bfd_boolean
774 do_slurp_coff_armap (bfd *abfd)
776 struct areltdata *mapdata;
777 int *raw_armap, *rawptr;
778 struct artdata *ardata = bfd_ardata (abfd);
779 char *stringbase;
780 bfd_size_type stringsize;
781 unsigned int parsed_size;
782 carsym *carsyms;
783 bfd_size_type nsymz; /* Number of symbols in armap. */
784 bfd_vma (*swap) (const void *);
785 char int_buf[sizeof (long)];
786 bfd_size_type carsym_size, ptrsize;
787 unsigned int i;
789 mapdata = _bfd_read_ar_hdr (abfd);
790 if (mapdata == NULL)
791 return FALSE;
792 parsed_size = mapdata->parsed_size;
793 bfd_release (abfd, mapdata); /* Don't need it any more. */
795 if (bfd_bread (int_buf, 4, abfd) != 4)
797 if (bfd_get_error () != bfd_error_system_call)
798 bfd_set_error (bfd_error_malformed_archive);
799 return FALSE;
801 /* It seems that all numeric information in a coff archive is always
802 in big endian format, nomatter the host or target. */
803 swap = bfd_getb32;
804 nsymz = bfd_getb32 (int_buf);
805 stringsize = parsed_size - (4 * nsymz) - 4;
807 /* ... except that some archive formats are broken, and it may be our
808 fault - the i960 little endian coff sometimes has big and sometimes
809 little, because our tools changed. Here's a horrible hack to clean
810 up the crap. */
812 if (stringsize > 0xfffff
813 && bfd_get_arch (abfd) == bfd_arch_i960
814 && bfd_get_flavour (abfd) == bfd_target_coff_flavour)
816 /* This looks dangerous, let's do it the other way around. */
817 nsymz = bfd_getl32 (int_buf);
818 stringsize = parsed_size - (4 * nsymz) - 4;
819 swap = bfd_getl32;
822 /* The coff armap must be read sequentially. So we construct a
823 bsd-style one in core all at once, for simplicity. */
825 if (nsymz > ~ (bfd_size_type) 0 / sizeof (carsym))
826 return FALSE;
828 carsym_size = (nsymz * sizeof (carsym));
829 ptrsize = (4 * nsymz);
831 if (carsym_size + stringsize + 1 <= carsym_size)
832 return FALSE;
834 ardata->symdefs = bfd_zalloc (abfd, carsym_size + stringsize + 1);
835 if (ardata->symdefs == NULL)
836 return FALSE;
837 carsyms = ardata->symdefs;
838 stringbase = ((char *) ardata->symdefs) + carsym_size;
840 /* Allocate and read in the raw offsets. */
841 raw_armap = bfd_alloc (abfd, ptrsize);
842 if (raw_armap == NULL)
843 goto release_symdefs;
844 if (bfd_bread (raw_armap, ptrsize, abfd) != ptrsize
845 || (bfd_bread (stringbase, stringsize, abfd) != stringsize))
847 if (bfd_get_error () != bfd_error_system_call)
848 bfd_set_error (bfd_error_malformed_archive);
849 goto release_raw_armap;
852 /* OK, build the carsyms. */
853 for (i = 0; i < nsymz; i++)
855 rawptr = raw_armap + i;
856 carsyms->file_offset = swap ((bfd_byte *) rawptr);
857 carsyms->name = stringbase;
858 stringbase += strlen (stringbase) + 1;
859 carsyms++;
861 *stringbase = 0;
863 ardata->symdef_count = nsymz;
864 ardata->first_file_filepos = bfd_tell (abfd);
865 /* Pad to an even boundary if you have to. */
866 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
868 bfd_has_map (abfd) = TRUE;
869 bfd_release (abfd, raw_armap);
871 /* Check for a second archive header (as used by PE). */
873 struct areltdata *tmp;
875 bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET);
876 tmp = _bfd_read_ar_hdr (abfd);
877 if (tmp != NULL)
879 if (tmp->arch_header[0] == '/'
880 && tmp->arch_header[1] == ' ')
882 ardata->first_file_filepos +=
883 (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1;
885 bfd_release (abfd, tmp);
889 return TRUE;
891 release_raw_armap:
892 bfd_release (abfd, raw_armap);
893 release_symdefs:
894 bfd_release (abfd, (ardata)->symdefs);
895 return FALSE;
898 /* This routine can handle either coff-style or bsd-style armaps.
899 Returns FALSE on error, TRUE otherwise */
901 bfd_boolean
902 bfd_slurp_armap (bfd *abfd)
904 char nextname[17];
905 int i = bfd_bread (nextname, 16, abfd);
907 if (i == 0)
908 return TRUE;
909 if (i != 16)
910 return FALSE;
912 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
913 return FALSE;
915 if (CONST_STRNEQ (nextname, "__.SYMDEF ")
916 || CONST_STRNEQ (nextname, "__.SYMDEF/ ")) /* Old Linux archives. */
917 return do_slurp_bsd_armap (abfd);
918 else if (CONST_STRNEQ (nextname, "/ "))
919 return do_slurp_coff_armap (abfd);
920 else if (CONST_STRNEQ (nextname, "/SYM64/ "))
922 /* 64bit ELF (Irix 6) archive. */
923 #ifdef BFD64
924 extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *);
925 return bfd_elf64_archive_slurp_armap (abfd);
926 #else
927 bfd_set_error (bfd_error_wrong_format);
928 return FALSE;
929 #endif
932 bfd_has_map (abfd) = FALSE;
933 return TRUE;
936 /* Returns FALSE on error, TRUE otherwise. */
937 /* Flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
938 header is in a slightly different order and the map name is '/'.
939 This flavour is used by hp300hpux. */
941 #define HPUX_SYMDEF_COUNT_SIZE 2
943 bfd_boolean
944 bfd_slurp_bsd_armap_f2 (bfd *abfd)
946 struct areltdata *mapdata;
947 char nextname[17];
948 unsigned int counter;
949 bfd_byte *raw_armap, *rbase;
950 struct artdata *ardata = bfd_ardata (abfd);
951 char *stringbase;
952 unsigned int stringsize;
953 bfd_size_type amt;
954 carsym *set;
955 int i = bfd_bread (nextname, 16, abfd);
957 if (i == 0)
958 return TRUE;
959 if (i != 16)
960 return FALSE;
962 /* The archive has at least 16 bytes in it. */
963 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
964 return FALSE;
966 if (CONST_STRNEQ (nextname, "__.SYMDEF ")
967 || CONST_STRNEQ (nextname, "__.SYMDEF/ ")) /* Old Linux archives. */
968 return do_slurp_bsd_armap (abfd);
970 if (! CONST_STRNEQ (nextname, "/ "))
972 bfd_has_map (abfd) = FALSE;
973 return TRUE;
976 mapdata = _bfd_read_ar_hdr (abfd);
977 if (mapdata == NULL)
978 return FALSE;
980 amt = mapdata->parsed_size;
981 raw_armap = bfd_zalloc (abfd, amt);
982 if (raw_armap == NULL)
984 byebye:
985 bfd_release (abfd, mapdata);
986 return FALSE;
989 if (bfd_bread (raw_armap, amt, abfd) != amt)
991 if (bfd_get_error () != bfd_error_system_call)
992 bfd_set_error (bfd_error_malformed_archive);
993 byebyebye:
994 bfd_release (abfd, raw_armap);
995 goto byebye;
998 ardata->symdef_count = H_GET_16 (abfd, raw_armap);
1000 if (ardata->symdef_count * BSD_SYMDEF_SIZE
1001 > mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE)
1003 /* Probably we're using the wrong byte ordering. */
1004 bfd_set_error (bfd_error_wrong_format);
1005 goto byebyebye;
1008 ardata->cache = 0;
1010 stringsize = H_GET_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE);
1011 /* Skip sym count and string sz. */
1012 stringbase = ((char *) raw_armap
1013 + HPUX_SYMDEF_COUNT_SIZE
1014 + BSD_STRING_COUNT_SIZE);
1015 rbase = (bfd_byte *) stringbase + stringsize;
1016 amt = ardata->symdef_count * BSD_SYMDEF_SIZE;
1017 ardata->symdefs = bfd_alloc (abfd, amt);
1018 if (!ardata->symdefs)
1019 return FALSE;
1021 for (counter = 0, set = ardata->symdefs;
1022 counter < ardata->symdef_count;
1023 counter++, set++, rbase += BSD_SYMDEF_SIZE)
1025 set->name = H_GET_32 (abfd, rbase) + stringbase;
1026 set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
1029 ardata->first_file_filepos = bfd_tell (abfd);
1030 /* Pad to an even boundary if you have to. */
1031 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1032 /* FIXME, we should provide some way to free raw_ardata when
1033 we are done using the strings from it. For now, it seems
1034 to be allocated on an objalloc anyway... */
1035 bfd_has_map (abfd) = TRUE;
1036 return TRUE;
1039 /** Extended name table.
1041 Normally archives support only 14-character filenames.
1043 Intel has extended the format: longer names are stored in a special
1044 element (the first in the archive, or second if there is an armap);
1045 the name in the ar_hdr is replaced by <space><index into filename
1046 element>. Index is the P.R. of an int (decimal). Data General have
1047 extended the format by using the prefix // for the special element. */
1049 /* Returns FALSE on error, TRUE otherwise. */
1051 bfd_boolean
1052 _bfd_slurp_extended_name_table (bfd *abfd)
1054 char nextname[17];
1055 struct areltdata *namedata;
1056 bfd_size_type amt;
1058 /* FIXME: Formatting sucks here, and in case of failure of BFD_READ,
1059 we probably don't want to return TRUE. */
1060 bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET);
1061 if (bfd_bread (nextname, 16, abfd) == 16)
1063 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1064 return FALSE;
1066 if (! CONST_STRNEQ (nextname, "ARFILENAMES/ ")
1067 && ! CONST_STRNEQ (nextname, "// "))
1069 bfd_ardata (abfd)->extended_names = NULL;
1070 bfd_ardata (abfd)->extended_names_size = 0;
1071 return TRUE;
1074 namedata = _bfd_read_ar_hdr (abfd);
1075 if (namedata == NULL)
1076 return FALSE;
1078 amt = namedata->parsed_size;
1079 if (amt + 1 == 0)
1080 goto byebye;
1082 bfd_ardata (abfd)->extended_names_size = amt;
1083 bfd_ardata (abfd)->extended_names = bfd_zalloc (abfd, amt + 1);
1084 if (bfd_ardata (abfd)->extended_names == NULL)
1086 byebye:
1087 bfd_release (abfd, namedata);
1088 return FALSE;
1091 if (bfd_bread (bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
1093 if (bfd_get_error () != bfd_error_system_call)
1094 bfd_set_error (bfd_error_malformed_archive);
1095 bfd_release (abfd, (bfd_ardata (abfd)->extended_names));
1096 bfd_ardata (abfd)->extended_names = NULL;
1097 goto byebye;
1100 /* Since the archive is supposed to be printable if it contains
1101 text, the entries in the list are newline-padded, not null
1102 padded. In SVR4-style archives, the names also have a
1103 trailing '/'. DOS/NT created archive often have \ in them
1104 We'll fix all problems here.. */
1106 char *ext_names = bfd_ardata (abfd)->extended_names;
1107 char *temp = ext_names;
1108 char *limit = temp + namedata->parsed_size;
1109 for (; temp < limit; ++temp)
1111 if (*temp == '\012')
1112 temp[temp > ext_names && temp[-1] == '/' ? -1 : 0] = '\0';
1113 if (*temp == '\\')
1114 *temp = '/';
1116 *limit = '\0';
1119 /* Pad to an even boundary if you have to. */
1120 bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd);
1121 bfd_ardata (abfd)->first_file_filepos +=
1122 (bfd_ardata (abfd)->first_file_filepos) % 2;
1124 /* FIXME, we can't release namedata here because it was allocated
1125 below extended_names on the objalloc... */
1127 return TRUE;
1130 #ifdef VMS
1132 /* Return a copy of the stuff in the filename between any :]> and a
1133 semicolon. */
1135 static const char *
1136 normalize (bfd *abfd, const char *file)
1138 const char *first;
1139 const char *last;
1140 char *copy;
1142 first = file + strlen (file) - 1;
1143 last = first + 1;
1145 while (first != file)
1147 if (*first == ';')
1148 last = first;
1149 if (*first == ':' || *first == ']' || *first == '>')
1151 first++;
1152 break;
1154 first--;
1157 copy = bfd_alloc (abfd, last - first + 1);
1158 if (copy == NULL)
1159 return NULL;
1161 memcpy (copy, first, last - first);
1162 copy[last - first] = 0;
1164 return copy;
1167 #else
1168 static const char *
1169 normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file)
1171 const char *filename = strrchr (file, '/');
1173 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1175 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */
1176 char *bslash = strrchr (file, '\\');
1177 if (filename == NULL || (bslash != NULL && bslash > filename))
1178 filename = bslash;
1179 if (filename == NULL && file[0] != '\0' && file[1] == ':')
1180 filename = file + 1;
1182 #endif
1183 if (filename != NULL)
1184 filename++;
1185 else
1186 filename = file;
1187 return filename;
1189 #endif
1191 /* Build a BFD style extended name table. */
1193 bfd_boolean
1194 _bfd_archive_bsd_construct_extended_name_table (bfd *abfd,
1195 char **tabloc,
1196 bfd_size_type *tablen,
1197 const char **name)
1199 *name = "ARFILENAMES/";
1200 return _bfd_construct_extended_name_table (abfd, FALSE, tabloc, tablen);
1203 /* Build an SVR4 style extended name table. */
1205 bfd_boolean
1206 _bfd_archive_coff_construct_extended_name_table (bfd *abfd,
1207 char **tabloc,
1208 bfd_size_type *tablen,
1209 const char **name)
1211 *name = "//";
1212 return _bfd_construct_extended_name_table (abfd, TRUE, tabloc, tablen);
1215 /* Follows archive_head and produces an extended name table if
1216 necessary. Returns (in tabloc) a pointer to an extended name
1217 table, and in tablen the length of the table. If it makes an entry
1218 it clobbers the filename so that the element may be written without
1219 further massage. Returns TRUE if it ran successfully, FALSE if
1220 something went wrong. A successful return may still involve a
1221 zero-length tablen! */
1223 bfd_boolean
1224 _bfd_construct_extended_name_table (bfd *abfd,
1225 bfd_boolean trailing_slash,
1226 char **tabloc,
1227 bfd_size_type *tablen)
1229 unsigned int maxname = abfd->xvec->ar_max_namelen;
1230 bfd_size_type total_namelen = 0;
1231 bfd *current;
1232 char *strptr;
1234 *tablen = 0;
1236 /* Figure out how long the table should be. */
1237 for (current = abfd->archive_head; current != NULL; current = current->next)
1239 const char *normal;
1240 unsigned int thislen;
1242 normal = normalize (current, current->filename);
1243 if (normal == NULL)
1244 return FALSE;
1246 thislen = strlen (normal);
1248 if (thislen > maxname
1249 && (bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1250 thislen = maxname;
1252 if (thislen > maxname)
1254 /* Add one to leave room for \n. */
1255 total_namelen += thislen + 1;
1256 if (trailing_slash)
1258 /* Leave room for trailing slash. */
1259 ++total_namelen;
1262 else
1264 struct ar_hdr *hdr = arch_hdr (current);
1265 if (strncmp (normal, hdr->ar_name, thislen) != 0
1266 || (thislen < sizeof hdr->ar_name
1267 && hdr->ar_name[thislen] != ar_padchar (current)))
1269 /* Must have been using extended format even though it
1270 didn't need to. Fix it to use normal format. */
1271 memcpy (hdr->ar_name, normal, thislen);
1272 if (thislen < maxname
1273 || (thislen == maxname && thislen < sizeof hdr->ar_name))
1274 hdr->ar_name[thislen] = ar_padchar (current);
1279 if (total_namelen == 0)
1280 return TRUE;
1282 *tabloc = bfd_zalloc (abfd, total_namelen);
1283 if (*tabloc == NULL)
1284 return FALSE;
1286 *tablen = total_namelen;
1287 strptr = *tabloc;
1289 for (current = abfd->archive_head; current != NULL; current =
1290 current->next)
1292 const char *normal;
1293 unsigned int thislen;
1295 normal = normalize (current, current->filename);
1296 if (normal == NULL)
1297 return FALSE;
1299 thislen = strlen (normal);
1300 if (thislen > maxname)
1302 /* Works for now; may need to be re-engineered if we
1303 encounter an oddball archive format and want to
1304 generalise this hack. */
1305 struct ar_hdr *hdr = arch_hdr (current);
1306 strcpy (strptr, normal);
1307 if (! trailing_slash)
1308 strptr[thislen] = '\012';
1309 else
1311 strptr[thislen] = '/';
1312 strptr[thislen + 1] = '\012';
1314 hdr->ar_name[0] = ar_padchar (current);
1315 _bfd_ar_spacepad (hdr->ar_name + 1, maxname - 1, "%-ld",
1316 strptr - *tabloc);
1317 strptr += thislen + 1;
1318 if (trailing_slash)
1319 ++strptr;
1323 return TRUE;
1326 /* A couple of functions for creating ar_hdrs. */
1328 #ifdef HPUX_LARGE_AR_IDS
1329 /* Function to encode large UID/GID values according to HP. */
1331 static void
1332 hpux_uid_gid_encode (char str[6], long int id)
1334 int cnt;
1336 str[5] = '@' + (id & 3);
1337 id >>= 2;
1339 for (cnt = 4; cnt >= 0; --cnt, id >>= 6)
1340 str[cnt] = ' ' + (id & 0x3f);
1342 #endif /* HPUX_LARGE_AR_IDS */
1344 #ifndef HAVE_GETUID
1345 #define getuid() 0
1346 #endif
1348 #ifndef HAVE_GETGID
1349 #define getgid() 0
1350 #endif
1352 /* Takes a filename, returns an arelt_data for it, or NULL if it can't
1353 make one. The filename must refer to a filename in the filesystem.
1354 The filename field of the ar_hdr will NOT be initialized. If member
1355 is set, and it's an in-memory bfd, we fake it. */
1357 static struct areltdata *
1358 bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
1360 struct stat status;
1361 struct areltdata *ared;
1362 struct ar_hdr *hdr;
1363 bfd_size_type amt;
1365 if (member && (member->flags & BFD_IN_MEMORY) != 0)
1367 /* Assume we just "made" the member, and fake it. */
1368 struct bfd_in_memory *bim = member->iostream;
1369 time (&status.st_mtime);
1370 status.st_uid = getuid ();
1371 status.st_gid = getgid ();
1372 status.st_mode = 0644;
1373 status.st_size = bim->size;
1375 else if (stat (filename, &status) != 0)
1377 bfd_set_error (bfd_error_system_call);
1378 return NULL;
1381 amt = sizeof (struct ar_hdr) + sizeof (struct areltdata);
1382 ared = bfd_zalloc (abfd, amt);
1383 if (ared == NULL)
1384 return NULL;
1385 hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));
1387 /* ar headers are space padded, not null padded! */
1388 memset (hdr, ' ', sizeof (struct ar_hdr));
1390 _bfd_ar_spacepad (hdr->ar_date, sizeof (hdr->ar_date), "%-12ld",
1391 status.st_mtime);
1392 #ifdef HPUX_LARGE_AR_IDS
1393 /* HP has a very "special" way to handle UID/GID's with numeric values
1394 > 99999. */
1395 if (status.st_uid > 99999)
1396 hpux_uid_gid_encode (hdr->ar_uid, (long) status.st_uid);
1397 else
1398 #endif
1399 _bfd_ar_spacepad (hdr->ar_uid, sizeof (hdr->ar_uid), "%ld",
1400 status.st_uid);
1401 #ifdef HPUX_LARGE_AR_IDS
1402 /* HP has a very "special" way to handle UID/GID's with numeric values
1403 > 99999. */
1404 if (status.st_gid > 99999)
1405 hpux_uid_gid_encode (hdr->ar_gid, (long) status.st_gid);
1406 else
1407 #endif
1408 _bfd_ar_spacepad (hdr->ar_gid, sizeof (hdr->ar_gid), "%ld",
1409 status.st_gid);
1410 _bfd_ar_spacepad (hdr->ar_mode, sizeof (hdr->ar_mode), "%-8lo",
1411 status.st_mode);
1412 _bfd_ar_spacepad (hdr->ar_size, sizeof (hdr->ar_size), "%-10ld",
1413 status.st_size);
1414 memcpy (hdr->ar_fmag, ARFMAG, 2);
1415 ared->parsed_size = status.st_size;
1416 ared->arch_header = (char *) hdr;
1418 return ared;
1421 /* This is magic required by the "ar" program. Since it's
1422 undocumented, it's undocumented. You may think that it would take
1423 a strong stomach to write this, and it does, but it takes even a
1424 stronger stomach to try to code around such a thing! */
1426 struct ar_hdr *bfd_special_undocumented_glue (bfd *, const char *);
1428 struct ar_hdr *
1429 bfd_special_undocumented_glue (bfd *abfd, const char *filename)
1431 struct areltdata *ar_elt = bfd_ar_hdr_from_filesystem (abfd, filename, 0);
1432 if (ar_elt == NULL)
1433 return NULL;
1434 return (struct ar_hdr *) ar_elt->arch_header;
1437 /* Analogous to stat call. */
1440 bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
1442 struct ar_hdr *hdr;
1443 char *aloser;
1445 if (abfd->arelt_data == NULL)
1447 bfd_set_error (bfd_error_invalid_operation);
1448 return -1;
1451 hdr = arch_hdr (abfd);
1453 #define foo(arelt, stelt, size) \
1454 buf->stelt = strtol (hdr->arelt, &aloser, size); \
1455 if (aloser == hdr->arelt) \
1456 return -1;
1458 /* Some platforms support special notations for large IDs. */
1459 #ifdef HPUX_LARGE_AR_IDS
1460 # define foo2(arelt, stelt, size) \
1461 if (hdr->arelt[5] == ' ') \
1463 foo (arelt, stelt, size); \
1465 else \
1467 int cnt; \
1468 for (buf->stelt = cnt = 0; cnt < 5; ++cnt) \
1470 if (hdr->arelt[cnt] < ' ' || hdr->arelt[cnt] > ' ' + 0x3f) \
1471 return -1; \
1472 buf->stelt <<= 6; \
1473 buf->stelt += hdr->arelt[cnt] - ' '; \
1475 if (hdr->arelt[5] < '@' || hdr->arelt[5] > '@' + 3) \
1476 return -1; \
1477 buf->stelt <<= 2; \
1478 buf->stelt += hdr->arelt[5] - '@'; \
1480 #else
1481 # define foo2(arelt, stelt, size) foo (arelt, stelt, size)
1482 #endif
1484 foo (ar_date, st_mtime, 10);
1485 foo2 (ar_uid, st_uid, 10);
1486 foo2 (ar_gid, st_gid, 10);
1487 foo (ar_mode, st_mode, 8);
1489 buf->st_size = arch_eltdata (abfd)->parsed_size;
1491 return 0;
1494 void
1495 bfd_dont_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1497 /* FIXME: This interacts unpleasantly with ar's quick-append option.
1498 Fortunately ic960 users will never use that option. Fixing this
1499 is very hard; fortunately I know how to do it and will do so once
1500 intel's release is out the door. */
1502 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1503 size_t length;
1504 const char *filename;
1505 size_t maxlen = ar_maxnamelen (abfd);
1507 if ((bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1509 bfd_bsd_truncate_arname (abfd, pathname, arhdr);
1510 return;
1513 filename = normalize (abfd, pathname);
1514 if (filename == NULL)
1516 /* FIXME */
1517 abort ();
1520 length = strlen (filename);
1522 if (length <= maxlen)
1523 memcpy (hdr->ar_name, filename, length);
1525 /* Add the padding character if there is room for it. */
1526 if (length < maxlen
1527 || (length == maxlen && length < sizeof hdr->ar_name))
1528 (hdr->ar_name)[length] = ar_padchar (abfd);
1531 void
1532 bfd_bsd_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1534 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1535 size_t length;
1536 const char *filename = strrchr (pathname, '/');
1537 size_t maxlen = ar_maxnamelen (abfd);
1539 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1541 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */
1542 char *bslash = strrchr (pathname, '\\');
1543 if (filename == NULL || (bslash != NULL && bslash > filename))
1544 filename = bslash;
1545 if (filename == NULL && pathname[0] != '\0' && pathname[1] == ':')
1546 filename = pathname + 1;
1548 #endif
1550 if (filename == NULL)
1551 filename = pathname;
1552 else
1553 ++filename;
1555 length = strlen (filename);
1557 if (length <= maxlen)
1558 memcpy (hdr->ar_name, filename, length);
1559 else
1561 /* pathname: meet procrustes */
1562 memcpy (hdr->ar_name, filename, maxlen);
1563 length = maxlen;
1566 if (length < maxlen)
1567 (hdr->ar_name)[length] = ar_padchar (abfd);
1570 /* Store name into ar header. Truncates the name to fit.
1571 1> strip pathname to be just the basename.
1572 2> if it's short enuf to fit, stuff it in.
1573 3> If it doesn't end with .o, truncate it to fit
1574 4> truncate it before the .o, append .o, stuff THAT in. */
1576 /* This is what gnu ar does. It's better but incompatible with the
1577 bsd ar. */
1579 void
1580 bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1582 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1583 size_t length;
1584 const char *filename = strrchr (pathname, '/');
1585 size_t maxlen = ar_maxnamelen (abfd);
1587 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1589 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */
1590 char *bslash = strrchr (pathname, '\\');
1591 if (filename == NULL || (bslash != NULL && bslash > filename))
1592 filename = bslash;
1593 if (filename == NULL && pathname[0] != '\0' && pathname[1] == ':')
1594 filename = pathname + 1;
1596 #endif
1598 if (filename == NULL)
1599 filename = pathname;
1600 else
1601 ++filename;
1603 length = strlen (filename);
1605 if (length <= maxlen)
1606 memcpy (hdr->ar_name, filename, length);
1607 else
1608 { /* pathname: meet procrustes */
1609 memcpy (hdr->ar_name, filename, maxlen);
1610 if ((filename[length - 2] == '.') && (filename[length - 1] == 'o'))
1612 hdr->ar_name[maxlen - 2] = '.';
1613 hdr->ar_name[maxlen - 1] = 'o';
1615 length = maxlen;
1618 if (length < 16)
1619 (hdr->ar_name)[length] = ar_padchar (abfd);
1622 /* The BFD is open for write and has its format set to bfd_archive. */
1624 bfd_boolean
1625 _bfd_write_archive_contents (bfd *arch)
1627 bfd *current;
1628 char *etable = NULL;
1629 bfd_size_type elength = 0;
1630 const char *ename = NULL;
1631 bfd_boolean makemap = bfd_has_map (arch);
1632 /* If no .o's, don't bother to make a map. */
1633 bfd_boolean hasobjects = FALSE;
1634 bfd_size_type wrote;
1635 int tries;
1637 /* Verify the viability of all entries; if any of them live in the
1638 filesystem (as opposed to living in an archive open for input)
1639 then construct a fresh ar_hdr for them. */
1640 for (current = arch->archive_head; current; current = current->next)
1642 /* This check is checking the bfds for the objects we're reading
1643 from (which are usually either an object file or archive on
1644 disk), not the archive entries we're writing to. We don't
1645 actually create bfds for the archive members, we just copy
1646 them byte-wise when we write out the archive. */
1647 if (bfd_write_p (current))
1649 bfd_set_error (bfd_error_invalid_operation);
1650 goto input_err;
1652 if (!current->arelt_data)
1654 current->arelt_data =
1655 bfd_ar_hdr_from_filesystem (arch, current->filename, current);
1656 if (!current->arelt_data)
1657 goto input_err;
1659 /* Put in the file name. */
1660 BFD_SEND (arch, _bfd_truncate_arname,
1661 (arch, current->filename, (char *) arch_hdr (current)));
1664 if (makemap && ! hasobjects)
1665 { /* Don't bother if we won't make a map! */
1666 if ((bfd_check_format (current, bfd_object)))
1667 hasobjects = TRUE;
1671 if (!BFD_SEND (arch, _bfd_construct_extended_name_table,
1672 (arch, &etable, &elength, &ename)))
1673 return FALSE;
1675 if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0)
1676 return FALSE;
1677 wrote = bfd_bwrite (ARMAG, SARMAG, arch);
1678 if (wrote != SARMAG)
1679 return FALSE;
1681 if (makemap && hasobjects)
1683 if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength))
1684 return FALSE;
1687 if (elength != 0)
1689 struct ar_hdr hdr;
1691 memset (&hdr, ' ', sizeof (struct ar_hdr));
1692 memcpy (hdr.ar_name, ename, strlen (ename));
1693 /* Round size up to even number in archive header. */
1694 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld",
1695 (elength + 1) & ~(bfd_size_type) 1);
1696 memcpy (hdr.ar_fmag, ARFMAG, 2);
1697 if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
1698 != sizeof (struct ar_hdr))
1699 || bfd_bwrite (etable, elength, arch) != elength)
1700 return FALSE;
1701 if ((elength % 2) == 1)
1703 if (bfd_bwrite ("\012", 1, arch) != 1)
1704 return FALSE;
1708 for (current = arch->archive_head; current; current = current->next)
1710 char buffer[DEFAULT_BUFFERSIZE];
1711 unsigned int remaining = arelt_size (current);
1712 struct ar_hdr *hdr = arch_hdr (current);
1714 /* Write ar header. */
1715 if (bfd_bwrite (hdr, sizeof (*hdr), arch)
1716 != sizeof (*hdr))
1717 return FALSE;
1718 if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
1719 goto input_err;
1720 while (remaining)
1722 unsigned int amt = DEFAULT_BUFFERSIZE;
1723 if (amt > remaining)
1724 amt = remaining;
1725 errno = 0;
1726 if (bfd_bread (buffer, amt, current) != amt)
1728 if (bfd_get_error () != bfd_error_system_call)
1729 bfd_set_error (bfd_error_file_truncated);
1730 goto input_err;
1732 if (bfd_bwrite (buffer, amt, arch) != amt)
1733 return FALSE;
1734 remaining -= amt;
1736 if ((arelt_size (current) % 2) == 1)
1738 if (bfd_bwrite ("\012", 1, arch) != 1)
1739 return FALSE;
1743 if (makemap && hasobjects)
1745 /* Verify the timestamp in the archive file. If it would not be
1746 accepted by the linker, rewrite it until it would be. If
1747 anything odd happens, break out and just return. (The
1748 Berkeley linker checks the timestamp and refuses to read the
1749 table-of-contents if it is >60 seconds less than the file's
1750 modified-time. That painful hack requires this painful hack. */
1751 tries = 1;
1754 if (bfd_update_armap_timestamp (arch))
1755 break;
1756 (*_bfd_error_handler)
1757 (_("Warning: writing archive was slow: rewriting timestamp\n"));
1759 while (++tries < 6);
1762 return TRUE;
1764 input_err:
1765 bfd_set_error (bfd_error_on_input, current, bfd_get_error ());
1766 return FALSE;
1769 /* Note that the namidx for the first symbol is 0. */
1771 bfd_boolean
1772 _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
1774 char *first_name = NULL;
1775 bfd *current;
1776 file_ptr elt_no = 0;
1777 struct orl *map = NULL;
1778 unsigned int orl_max = 1024; /* Fine initial default. */
1779 unsigned int orl_count = 0;
1780 int stridx = 0;
1781 asymbol **syms = NULL;
1782 long syms_max = 0;
1783 bfd_boolean ret;
1784 bfd_size_type amt;
1786 /* Dunno if this is the best place for this info... */
1787 if (elength != 0)
1788 elength += sizeof (struct ar_hdr);
1789 elength += elength % 2;
1791 amt = orl_max * sizeof (struct orl);
1792 map = bfd_malloc (amt);
1793 if (map == NULL)
1794 goto error_return;
1796 /* We put the symbol names on the arch objalloc, and then discard
1797 them when done. */
1798 first_name = bfd_alloc (arch, 1);
1799 if (first_name == NULL)
1800 goto error_return;
1802 /* Drop all the files called __.SYMDEF, we're going to make our own. */
1803 while (arch->archive_head &&
1804 strcmp (arch->archive_head->filename, "__.SYMDEF") == 0)
1805 arch->archive_head = arch->archive_head->next;
1807 /* Map over each element. */
1808 for (current = arch->archive_head;
1809 current != NULL;
1810 current = current->next, elt_no++)
1812 if (bfd_check_format (current, bfd_object)
1813 && (bfd_get_file_flags (current) & HAS_SYMS) != 0)
1815 long storage;
1816 long symcount;
1817 long src_count;
1819 storage = bfd_get_symtab_upper_bound (current);
1820 if (storage < 0)
1821 goto error_return;
1823 if (storage != 0)
1825 if (storage > syms_max)
1827 if (syms_max > 0)
1828 free (syms);
1829 syms_max = storage;
1830 syms = bfd_malloc (syms_max);
1831 if (syms == NULL)
1832 goto error_return;
1834 symcount = bfd_canonicalize_symtab (current, syms);
1835 if (symcount < 0)
1836 goto error_return;
1838 /* Now map over all the symbols, picking out the ones we
1839 want. */
1840 for (src_count = 0; src_count < symcount; src_count++)
1842 flagword flags = (syms[src_count])->flags;
1843 asection *sec = syms[src_count]->section;
1845 if ((flags & BSF_GLOBAL ||
1846 flags & BSF_WEAK ||
1847 flags & BSF_INDIRECT ||
1848 bfd_is_com_section (sec))
1849 && ! bfd_is_und_section (sec))
1851 bfd_size_type namelen;
1852 struct orl *new_map;
1854 /* This symbol will go into the archive header. */
1855 if (orl_count == orl_max)
1857 orl_max *= 2;
1858 amt = orl_max * sizeof (struct orl);
1859 new_map = bfd_realloc (map, amt);
1860 if (new_map == NULL)
1861 goto error_return;
1863 map = new_map;
1866 namelen = strlen (syms[src_count]->name);
1867 amt = sizeof (char *);
1868 map[orl_count].name = bfd_alloc (arch, amt);
1869 if (map[orl_count].name == NULL)
1870 goto error_return;
1871 *(map[orl_count].name) = bfd_alloc (arch, namelen + 1);
1872 if (*(map[orl_count].name) == NULL)
1873 goto error_return;
1874 strcpy (*(map[orl_count].name), syms[src_count]->name);
1875 map[orl_count].u.abfd = current;
1876 map[orl_count].namidx = stridx;
1878 stridx += namelen + 1;
1879 ++orl_count;
1884 /* Now ask the BFD to free up any cached information, so we
1885 don't fill all of memory with symbol tables. */
1886 if (! bfd_free_cached_info (current))
1887 goto error_return;
1891 /* OK, now we have collected all the data, let's write them out. */
1892 ret = BFD_SEND (arch, write_armap,
1893 (arch, elength, map, orl_count, stridx));
1895 if (syms_max > 0)
1896 free (syms);
1897 if (map != NULL)
1898 free (map);
1899 if (first_name != NULL)
1900 bfd_release (arch, first_name);
1902 return ret;
1904 error_return:
1905 if (syms_max > 0)
1906 free (syms);
1907 if (map != NULL)
1908 free (map);
1909 if (first_name != NULL)
1910 bfd_release (arch, first_name);
1912 return FALSE;
1915 bfd_boolean
1916 bsd_write_armap (bfd *arch,
1917 unsigned int elength,
1918 struct orl *map,
1919 unsigned int orl_count,
1920 int stridx)
1922 int padit = stridx & 1;
1923 unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE;
1924 unsigned int stringsize = stridx + padit;
1925 /* Include 8 bytes to store ranlibsize and stringsize in output. */
1926 unsigned int mapsize = ranlibsize + stringsize + 8;
1927 file_ptr firstreal;
1928 bfd *current = arch->archive_head;
1929 bfd *last_elt = current; /* Last element arch seen. */
1930 bfd_byte temp[4];
1931 unsigned int count;
1932 struct ar_hdr hdr;
1933 struct stat statbuf;
1935 firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
1937 stat (arch->filename, &statbuf);
1938 memset (&hdr, ' ', sizeof (struct ar_hdr));
1939 memcpy (hdr.ar_name, RANLIBMAG, strlen (RANLIBMAG));
1940 /* Remember the timestamp, to keep it holy. But fudge it a little. */
1941 bfd_ardata (arch)->armap_timestamp = statbuf.st_mtime + ARMAP_TIME_OFFSET;
1942 bfd_ardata (arch)->armap_datepos = (SARMAG
1943 + offsetof (struct ar_hdr, ar_date[0]));
1944 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
1945 bfd_ardata (arch)->armap_timestamp);
1946 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", getuid ());
1947 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", getgid ());
1948 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld", mapsize);
1949 memcpy (hdr.ar_fmag, ARFMAG, 2);
1950 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
1951 != sizeof (struct ar_hdr))
1952 return FALSE;
1953 H_PUT_32 (arch, ranlibsize, temp);
1954 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
1955 return FALSE;
1957 for (count = 0; count < orl_count; count++)
1959 bfd_byte buf[BSD_SYMDEF_SIZE];
1961 if (map[count].u.abfd != last_elt)
1965 firstreal += arelt_size (current) + sizeof (struct ar_hdr);
1966 firstreal += firstreal % 2;
1967 current = current->next;
1969 while (current != map[count].u.abfd);
1972 last_elt = current;
1973 H_PUT_32 (arch, map[count].namidx, buf);
1974 H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE);
1975 if (bfd_bwrite (buf, BSD_SYMDEF_SIZE, arch)
1976 != BSD_SYMDEF_SIZE)
1977 return FALSE;
1980 /* Now write the strings themselves. */
1981 H_PUT_32 (arch, stringsize, temp);
1982 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
1983 return FALSE;
1984 for (count = 0; count < orl_count; count++)
1986 size_t len = strlen (*map[count].name) + 1;
1988 if (bfd_bwrite (*map[count].name, len, arch) != len)
1989 return FALSE;
1992 /* The spec sez this should be a newline. But in order to be
1993 bug-compatible for sun's ar we use a null. */
1994 if (padit)
1996 if (bfd_bwrite ("", 1, arch) != 1)
1997 return FALSE;
2000 return TRUE;
2003 /* At the end of archive file handling, update the timestamp in the
2004 file, so the linker will accept it.
2006 Return TRUE if the timestamp was OK, or an unusual problem happened.
2007 Return FALSE if we updated the timestamp. */
2009 bfd_boolean
2010 _bfd_archive_bsd_update_armap_timestamp (bfd *arch)
2012 struct stat archstat;
2013 struct ar_hdr hdr;
2015 /* Flush writes, get last-write timestamp from file, and compare it
2016 to the timestamp IN the file. */
2017 bfd_flush (arch);
2018 if (bfd_stat (arch, &archstat) == -1)
2020 bfd_perror (_("Reading archive file mod timestamp"));
2022 /* Can't read mod time for some reason. */
2023 return TRUE;
2025 if (archstat.st_mtime <= bfd_ardata (arch)->armap_timestamp)
2026 /* OK by the linker's rules. */
2027 return TRUE;
2029 /* Update the timestamp. */
2030 bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET;
2032 /* Prepare an ASCII version suitable for writing. */
2033 memset (hdr.ar_date, ' ', sizeof (hdr.ar_date));
2034 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2035 bfd_ardata (arch)->armap_timestamp);
2037 /* Write it into the file. */
2038 bfd_ardata (arch)->armap_datepos = (SARMAG
2039 + offsetof (struct ar_hdr, ar_date[0]));
2040 if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0
2041 || (bfd_bwrite (hdr.ar_date, sizeof (hdr.ar_date), arch)
2042 != sizeof (hdr.ar_date)))
2044 bfd_perror (_("Writing updated armap timestamp"));
2046 /* Some error while writing. */
2047 return TRUE;
2050 /* We updated the timestamp successfully. */
2051 return FALSE;
2054 /* A coff armap looks like :
2055 lARMAG
2056 struct ar_hdr with name = '/'
2057 number of symbols
2058 offset of file for symbol 0
2059 offset of file for symbol 1
2061 offset of file for symbol n-1
2062 symbol name 0
2063 symbol name 1
2065 symbol name n-1 */
2067 bfd_boolean
2068 coff_write_armap (bfd *arch,
2069 unsigned int elength,
2070 struct orl *map,
2071 unsigned int symbol_count,
2072 int stridx)
2074 /* The size of the ranlib is the number of exported symbols in the
2075 archive * the number of bytes in an int, + an int for the count. */
2076 unsigned int ranlibsize = (symbol_count * 4) + 4;
2077 unsigned int stringsize = stridx;
2078 unsigned int mapsize = stringsize + ranlibsize;
2079 unsigned int archive_member_file_ptr;
2080 bfd *current = arch->archive_head;
2081 unsigned int count;
2082 struct ar_hdr hdr;
2083 int padit = mapsize & 1;
2085 if (padit)
2086 mapsize++;
2088 /* Work out where the first object file will go in the archive. */
2089 archive_member_file_ptr = (mapsize
2090 + elength
2091 + sizeof (struct ar_hdr)
2092 + SARMAG);
2094 memset (&hdr, ' ', sizeof (struct ar_hdr));
2095 hdr.ar_name[0] = '/';
2096 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld",
2097 mapsize);
2098 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2099 time (NULL));
2100 /* This, at least, is what Intel coff sets the values to. */
2101 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", 0);
2102 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", 0);
2103 _bfd_ar_spacepad (hdr.ar_mode, sizeof (hdr.ar_mode), "%-7lo", 0);
2104 memcpy (hdr.ar_fmag, ARFMAG, 2);
2106 /* Write the ar header for this item and the number of symbols. */
2107 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2108 != sizeof (struct ar_hdr))
2109 return FALSE;
2111 if (!bfd_write_bigendian_4byte_int (arch, symbol_count))
2112 return FALSE;
2114 /* Two passes, first write the file offsets for each symbol -
2115 remembering that each offset is on a two byte boundary. */
2117 /* Write out the file offset for the file associated with each
2118 symbol, and remember to keep the offsets padded out. */
2120 current = arch->archive_head;
2121 count = 0;
2122 while (current != NULL && count < symbol_count)
2124 /* For each symbol which is used defined in this object, write
2125 out the object file's address in the archive. */
2127 while (count < symbol_count && map[count].u.abfd == current)
2129 if (!bfd_write_bigendian_4byte_int (arch, archive_member_file_ptr))
2130 return FALSE;
2131 count++;
2133 /* Add size of this archive entry. */
2134 archive_member_file_ptr += arelt_size (current) + sizeof (struct ar_hdr);
2135 /* Remember aboout the even alignment. */
2136 archive_member_file_ptr += archive_member_file_ptr % 2;
2137 current = current->next;
2140 /* Now write the strings themselves. */
2141 for (count = 0; count < symbol_count; count++)
2143 size_t len = strlen (*map[count].name) + 1;
2145 if (bfd_bwrite (*map[count].name, len, arch) != len)
2146 return FALSE;
2149 /* The spec sez this should be a newline. But in order to be
2150 bug-compatible for arc960 we use a null. */
2151 if (padit)
2153 if (bfd_bwrite ("", 1, arch) != 1)
2154 return FALSE;
2157 return TRUE;