1 /* BFD back-end for archive files (libraries).
2 Copyright 1990, 91, 92, 93, 94 Free Software Foundation, Inc.
3 Written by Cygnus Support. Mostly Gumby Henkel-Wallace's fault.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
22 @setfilename archive-info
27 An archive (or library) is just another BFD. It has a symbol
28 table, although there's not much a user program will do with it.
30 The big difference between an archive BFD and an ordinary BFD
31 is that the archive doesn't have sections. Instead it has a
32 chain of BFDs that are considered its contents. These BFDs can
33 be manipulated like any other. The BFDs contained in an
34 archive opened for reading will all be opened for reading. You
35 may put either input or output BFDs into an archive opened for
36 output; they will be handled correctly when the archive is closed.
38 Use <<bfd_openr_next_archived_file>> to step through
39 the contents of an archive opened for input. You don't
40 have to read the entire archive if you don't want
41 to! Read it until you find what you want.
43 Archive contents of output BFDs are chained through the
44 <<next>> pointer in a BFD. The first one is findable through
45 the <<archive_head>> slot of the archive. Set it with
46 <<bfd_set_archive_head>> (q.v.). A given BFD may be in only one
47 open output archive at a time.
49 As expected, the BFD archive code is more general than the
50 archive code of any given environment. BFD archives may
51 contain files of different formats (e.g., a.out and coff) and
52 even different architectures. You may even place archives
53 recursively into archives!
55 This can cause unexpected confusion, since some archive
56 formats are more expressive than others. For instance, Intel
57 COFF archives can preserve long filenames; SunOS a.out archives
58 cannot. If you move a file from the first to the second
59 format and back again, the filename may be truncated.
60 Likewise, different a.out environments have different
61 conventions as to how they truncate filenames, whether they
62 preserve directory names in filenames, etc. When
63 interoperating with native tools, be sure your files are
66 Beware: most of these formats do not react well to the
67 presence of spaces in filenames. We do the best we can, but
68 can't always handle this case due to restrictions in the format of
69 archives. Many Unix utilities are braindead in regards to
70 spaces and such in filenames anyway, so this shouldn't be much
73 Archives are supported in BFD in <<archive.c>>.
78 o - all archive elements start on an even boundary, newline padded;
79 o - all arch headers are char *;
80 o - all arch headers are the same size (across architectures).
83 /* Some formats provide a way to cram a long filename into the short
84 (16 chars) space provided by a BSD archive. The trick is: make a
85 special "file" in the front of the archive, sort of like the SYMDEF
86 entry. If the filename is too long to fit, put it in the extended
87 name table, and use its index as the filename. To prevent
88 confusion prepend the index with a space. This means you can't
89 have filenames that start with a space, but then again, many Unix
90 utilities can't handle that anyway.
92 This scheme unfortunately requires that you stand on your head in
93 order to write an archive since you need to put a magic file at the
94 front, and need to touch every entry to do so. C'est la vie.
96 We support two variants of this idea:
97 The SVR4 format (extended name table is named "//"),
98 and an extended pseudo-BSD variant (extended name table is named
99 "ARFILENAMES/"). The origin of the latter format is uncertain.
101 BSD 4.4 uses a third scheme: It writes a long filename
102 directly after the header. This allows 'ar q' to work.
103 We currently can read BSD 4.4 archives, but not write them.
106 /* Summary of archive member names:
108 Symbol table (must be first):
109 "__.SYMDEF " - Symbol table, Berkeley style, produced by ranlib.
110 "/ " - Symbol table, system 5 style.
112 Long name table (must be before regular file members):
113 "// " - Long name table, System 5 R4 style.
114 "ARFILENAMES/ " - Long name table, non-standard extended BSD (not BSD 4.4).
116 Regular file members with short names:
117 "filename.o/ " - Regular file, System 5 style (embedded spaces ok).
118 "filename.o " - Regular file, Berkeley style (no embedded spaces).
120 Regular files with long names (or embedded spaces, for BSD variants):
121 "/18 " - SVR4 style, name at offset 18 in name table.
122 "#1/23 " - Long name (or embedded paces) 23 characters long,
123 BSD 4.4 style, full name follows header.
124 Implemented for reading, not writing.
125 " 18 " - Long name 18 characters long, extended pseudo-BSD.
132 #include "aout/ranlib.h"
134 #include <string.h> /* For memchr, strrchr and friends */
142 #define BFD_GNU960_ARMAG(abfd) (BFD_COFF_FILE_P((abfd)) ? ARMAG : ARMAGB)
145 /* Can't define this in hosts/foo.h, because (e.g. in gprof) the hosts file
146 is included, then obstack.h, which thinks if offsetof is defined, it
147 doesn't need to include stddef.h. */
148 /* Define offsetof for those systems which lack it */
150 #if !defined (offsetof)
151 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
154 /* We keep a cache of archive filepointers to archive elements to
155 speed up searching the archive by filepos. We only add an entry to
156 the cache when we actually read one. We also don't sort the cache;
157 it's generally short enough to search linearly.
158 Note that the pointers here point to the front of the ar_hdr, not
159 to the front of the contents!
165 struct ar_cache *next;
168 #define ar_padchar(abfd) ((abfd)->xvec->ar_pad_char)
169 #define ar_maxnamelen(abfd) ((abfd)->xvec->ar_max_namelen)
171 #define arch_eltdata(bfd) ((struct areltdata *)((bfd)->arelt_data))
172 #define arch_hdr(bfd) ((struct ar_hdr *)arch_eltdata(bfd)->arch_header)
174 static char *get_extended_arelt_filename PARAMS ((bfd *arch,
176 static boolean do_slurp_bsd_armap PARAMS ((bfd *abfd));
177 static boolean do_slurp_coff_armap PARAMS ((bfd *abfd));
178 static const char *normalize PARAMS ((const char *file));
179 static boolean bfd_construct_extended_name_table PARAMS ((bfd *abfd,
182 static struct areltdata *bfd_ar_hdr_from_filesystem PARAMS ((bfd *abfd,
184 static boolean compute_and_write_armap PARAMS ((bfd *arch,
185 unsigned int elength));
186 static boolean bsd_update_armap_timestamp PARAMS ((bfd *arch));
189 _bfd_generic_mkarchive (abfd)
192 abfd->tdata.aout_ar_data = ((struct artdata *)
193 bfd_zalloc (abfd, sizeof (struct artdata)));
195 if (bfd_ardata (abfd) == NULL)
197 bfd_error = no_memory;
201 bfd_ardata (abfd)->cache = NULL;
202 bfd_ardata (abfd)->archive_head = NULL;
203 bfd_ardata (abfd)->symdefs = NULL;
204 bfd_ardata (abfd)->extended_names = NULL;
205 bfd_ardata (abfd)->tdata = NULL;
215 symindex bfd_get_next_mapent(bfd *abfd, symindex previous, carsym **sym);
218 Step through archive @var{abfd}'s symbol table (if it
219 has one). Successively update @var{sym} with the next symbol's
220 information, returning that symbol's (internal) index into the
223 Supply <<BFD_NO_MORE_SYMBOLS>> as the @var{previous} entry to get
224 the first one; returns <<BFD_NO_MORE_SYMBOLS>> when you've already
227 A <<carsym>> is a canonical archive symbol. The only
228 user-visible element is its name, a null-terminated string.
232 bfd_get_next_mapent (abfd, prev, entry)
237 if (!bfd_has_map (abfd))
239 bfd_error = invalid_operation;
240 return BFD_NO_MORE_SYMBOLS;
243 if (prev == BFD_NO_MORE_SYMBOLS)
245 else if (++prev >= bfd_ardata (abfd)->symdef_count)
246 return BFD_NO_MORE_SYMBOLS;
248 *entry = (bfd_ardata (abfd)->symdefs + prev);
252 /* To be called by backends only */
255 _bfd_create_empty_archive_element_shell (obfd)
260 nbfd = _bfd_new_bfd_contained_in (obfd);
263 bfd_error = no_memory;
274 boolean bfd_set_archive_head(bfd *output, bfd *new_head);
277 Set the head of the chain of
278 BFDs contained in the archive @var{output} to @var{new_head}.
282 bfd_set_archive_head (output_archive, new_head)
287 output_archive->archive_head = new_head;
292 _bfd_look_for_bfd_in_cache (arch_bfd, filepos)
296 struct ar_cache *current;
298 for (current = bfd_ardata (arch_bfd)->cache; current != NULL;
299 current = current->next)
300 if (current->ptr == filepos)
301 return current->arelt;
306 /* Kind of stupid to call cons for each one, but we don't do too many */
308 _bfd_add_bfd_to_archive_cache (arch_bfd, filepos, new_elt)
309 bfd *arch_bfd, *new_elt;
312 struct ar_cache *new_cache = ((struct ar_cache *)
313 bfd_zalloc (arch_bfd,
314 sizeof (struct ar_cache)));
316 if (new_cache == NULL)
318 bfd_error = no_memory;
322 new_cache->ptr = filepos;
323 new_cache->arelt = new_elt;
324 new_cache->next = (struct ar_cache *) NULL;
325 if (bfd_ardata (arch_bfd)->cache == NULL)
326 bfd_ardata (arch_bfd)->cache = new_cache;
329 struct ar_cache *current = bfd_ardata (arch_bfd)->cache;
331 while (current->next != NULL)
332 current = current->next;
333 current->next = new_cache;
339 /* The name begins with space. Hence the rest of the name is an index into
343 get_extended_arelt_filename (arch, name)
347 unsigned long index = 0;
349 /* Should extract string so that I can guarantee not to overflow into
350 the next region, but I'm too lazy. */
352 /* Skip first char, which is '/' in SVR4 or ' ' in some other variants. */
353 index = strtol (name + 1, NULL, 10);
356 bfd_error = malformed_archive;
360 return bfd_ardata (arch)->extended_names + index;
363 /* This functions reads an arch header and returns an areltdata pointer, or
366 Presumes the file pointer is already in the right place (ie pointing
367 to the ar_hdr in the file). Moves the file pointer; on success it
368 should be pointing to the front of the file contents; on failure it
369 could have been moved arbitrarily.
373 _bfd_snarf_ar_hdr (abfd)
381 char *hdrp = (char *) &hdr;
382 unsigned int parsed_size;
383 struct areltdata *ared;
384 char *filename = NULL;
385 unsigned int namelen = 0;
386 unsigned int allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
389 if (bfd_read ((PTR) hdrp, 1, sizeof (struct ar_hdr), abfd)
390 != sizeof (struct ar_hdr))
392 bfd_error = no_more_archived_files;
395 if (strncmp (hdr.ar_fmag, ARFMAG, 2))
397 bfd_error = malformed_archive;
402 parsed_size = strtol (hdr.ar_size, NULL, 10);
405 bfd_error = malformed_archive;
409 /* Extract the filename from the archive - there are two ways to
410 specify an extendend name table, either the first char of the
411 name is a space, or it's a slash. */
412 if ((hdr.ar_name[0] == '/'
413 || (hdr.ar_name[0] == ' '
414 && memchr (hdr.ar_name, '/', ar_maxnamelen (abfd)) == NULL))
415 && bfd_ardata (abfd)->extended_names != NULL)
417 filename = get_extended_arelt_filename (abfd, hdr.ar_name);
418 if (filename == NULL)
420 bfd_error = malformed_archive;
424 /* BSD4.4-style long filename.
425 Only implemented for reading, so far! */
426 else if (hdr.ar_name[0] == '#' && hdr.ar_name[1] == '1'
427 && hdr.ar_name[2] == '/' && isdigit (hdr.ar_name[3]))
429 /* BSD-4.4 extended name */
430 namelen = atoi (&hdr.ar_name[3]);
431 allocsize += namelen + 1;
432 parsed_size -= namelen;
434 allocptr = bfd_zalloc (abfd, allocsize);
435 if (allocptr == NULL)
437 bfd_error = no_memory;
441 + sizeof (struct areltdata)
442 + sizeof (struct ar_hdr));
443 if (bfd_read (filename, 1, namelen, abfd) != namelen)
445 bfd_error = no_more_archived_files;
448 filename[namelen] = '\0';
452 /* We judge the end of the name by looking for '/' or ' '.
453 Note: The SYSV format (terminated by '/') allows embedded
454 spaces, so only look for ' ' if we don't find '/'. */
457 while (hdr.ar_name[namelen] != '\0' &&
458 hdr.ar_name[namelen] != '/')
461 if (namelen == (unsigned) ar_maxnamelen (abfd))
464 while (hdr.ar_name[namelen] != ' '
465 && namelen < (unsigned) ar_maxnamelen (abfd))
471 allocsize += namelen + 1;
476 allocptr = bfd_zalloc (abfd, allocsize);
477 if (allocptr == NULL)
479 bfd_error = no_memory;
484 ared = (struct areltdata *) allocptr;
486 ared->arch_header = allocptr + sizeof (struct areltdata);
487 memcpy ((char *) ared->arch_header, (char *) &hdr, sizeof (struct ar_hdr));
488 ared->parsed_size = parsed_size;
490 if (filename != NULL)
491 ared->filename = filename;
494 ared->filename = allocptr + (sizeof (struct areltdata) +
495 sizeof (struct ar_hdr));
497 memcpy (ared->filename, hdr.ar_name, namelen);
498 ared->filename[namelen] = '\0';
504 /* This is an internal function; it's mainly used when indexing
505 through the archive symbol table, but also used to get the next
506 element, since it handles the bookkeeping so nicely for us. */
509 _bfd_get_elt_at_filepos (archive, filepos)
513 struct areltdata *new_areldata;
516 n_nfd = _bfd_look_for_bfd_in_cache (archive, filepos);
520 if (0 > bfd_seek (archive, filepos, SEEK_SET))
522 bfd_error = system_call_error;
526 if ((new_areldata = _bfd_snarf_ar_hdr (archive)) == NULL)
529 n_nfd = _bfd_create_empty_archive_element_shell (archive);
532 bfd_release (archive, (PTR) new_areldata);
536 n_nfd->origin = bfd_tell (archive);
537 n_nfd->arelt_data = (PTR) new_areldata;
538 n_nfd->filename = new_areldata->filename;
540 if (_bfd_add_bfd_to_archive_cache (archive, filepos, n_nfd))
544 bfd_release (archive, (PTR) n_nfd);
545 bfd_release (archive, (PTR) new_areldata);
554 bfd *bfd_get_elt_at_index(bfd *archive, int index);
557 Return the BFD which is referenced by the symbol in @var{archive}
558 indexed by @var{index}. @var{index} should have been returned by
559 <<bfd_get_next_mapent>> (q.v.).
563 bfd_get_elt_at_index (abfd, index)
569 entry = bfd_ardata (abfd)->symdefs + index;
570 return _bfd_get_elt_at_filepos (abfd, entry->file_offset);
575 bfd_openr_next_archived_file
578 bfd *bfd_openr_next_archived_file(bfd *archive, bfd *previous);
581 Provided a BFD, @var{archive}, containing an archive and NULL, open
582 an input BFD on the first contained element and returns that.
583 Subsequent calls should pass
584 the archive and the previous return value to return a created
585 BFD to the next contained element. NULL is returned when there
591 bfd_openr_next_archived_file (archive, last_file)
595 if ((bfd_get_format (archive) != bfd_archive) ||
596 (archive->direction == write_direction))
598 bfd_error = invalid_operation;
602 return BFD_SEND (archive,
603 openr_next_archived_file,
609 bfd_generic_openr_next_archived_file (archive, last_file)
616 filestart = bfd_ardata (archive)->first_file_filepos;
619 unsigned int size = arelt_size (last_file);
620 /* Pad to an even boundary...
621 Note that last_file->origin can be odd in the case of
622 BSD-4.4-style element with a long odd size. */
623 filestart = last_file->origin + size;
624 filestart += filestart % 2;
627 return _bfd_get_elt_at_filepos (archive, filestart);
632 bfd_generic_archive_p (abfd)
635 char armag[SARMAG + 1];
637 if (bfd_read ((PTR) armag, 1, SARMAG, abfd) != SARMAG)
639 bfd_error = wrong_format;
644 if (strncmp (armag, BFD_GNU960_ARMAG (abfd), SARMAG) != 0)
647 if (strncmp (armag, ARMAG, SARMAG) != 0 &&
648 strncmp (armag, ARMAGB, SARMAG) != 0)
652 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
653 involves a cast, we can't do it as the left operand of assignment. */
654 abfd->tdata.aout_ar_data = ((struct artdata *)
655 bfd_zalloc (abfd, sizeof (struct artdata)));
657 if (bfd_ardata (abfd) == NULL)
659 bfd_error = no_memory;
663 bfd_ardata (abfd)->first_file_filepos = SARMAG;
664 bfd_ardata (abfd)->cache = NULL;
665 bfd_ardata (abfd)->archive_head = NULL;
666 bfd_ardata (abfd)->symdefs = NULL;
667 bfd_ardata (abfd)->extended_names = NULL;
668 bfd_ardata (abfd)->tdata = NULL;
670 if (!BFD_SEND (abfd, _bfd_slurp_armap, (abfd)))
672 bfd_release (abfd, bfd_ardata (abfd));
673 abfd->tdata.aout_ar_data = NULL;
677 if (!BFD_SEND (abfd, _bfd_slurp_extended_name_table, (abfd)))
679 bfd_release (abfd, bfd_ardata (abfd));
680 abfd->tdata.aout_ar_data = NULL;
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 bfd_h_get_32 to bfd_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 */
707 do_slurp_bsd_armap (abfd)
710 struct areltdata *mapdata;
711 unsigned int counter;
712 bfd_byte *raw_armap, *rbase;
713 struct artdata *ardata = bfd_ardata (abfd);
715 unsigned int parsed_size;
718 mapdata = _bfd_snarf_ar_hdr (abfd);
721 parsed_size = mapdata->parsed_size;
722 bfd_release (abfd, (PTR) mapdata); /* Don't need it any more. */
724 raw_armap = (bfd_byte *) bfd_zalloc (abfd, parsed_size);
725 if (raw_armap == (bfd_byte *) NULL)
727 bfd_error = no_memory;
731 if (bfd_read ((PTR) raw_armap, 1, parsed_size, abfd) != parsed_size)
733 bfd_error = malformed_archive;
735 bfd_release (abfd, (PTR) raw_armap);
739 ardata->symdef_count = bfd_h_get_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE;
741 if (ardata->symdef_count * BSD_SYMDEF_SIZE >
742 parsed_size - BSD_SYMDEF_COUNT_SIZE)
744 /* Probably we're using the wrong byte ordering. */
745 bfd_error = wrong_format;
750 rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE;
751 stringbase = ((char *) rbase
752 + ardata->symdef_count * BSD_SYMDEF_SIZE
753 + BSD_STRING_COUNT_SIZE);
754 ardata->symdefs = (carsym *) bfd_alloc (abfd,
755 (ardata->symdef_count
758 for (counter = 0, set = ardata->symdefs;
759 counter < ardata->symdef_count;
760 counter++, set++, rbase += BSD_SYMDEF_SIZE)
762 set->name = bfd_h_get_32 (abfd, rbase) + stringbase;
763 set->file_offset = bfd_h_get_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
766 ardata->first_file_filepos = bfd_tell (abfd);
767 /* Pad to an even boundary if you have to */
768 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
769 /* FIXME, we should provide some way to free raw_ardata when
770 we are done using the strings from it. For now, it seems
771 to be allocated on an obstack anyway... */
772 bfd_has_map (abfd) = true;
776 /* Returns false on error, true otherwise */
778 do_slurp_coff_armap (abfd)
781 struct areltdata *mapdata;
782 int *raw_armap, *rawptr;
783 struct artdata *ardata = bfd_ardata (abfd);
785 unsigned int stringsize;
786 unsigned int parsed_size;
788 unsigned int nsymz; /* Number of symbols in armap. */
789 bfd_vma (*swap) PARAMS ((const bfd_byte *));
790 char int_buf[sizeof (long)];
791 unsigned int carsym_size, ptrsize, i;
793 mapdata = _bfd_snarf_ar_hdr (abfd);
796 parsed_size = mapdata->parsed_size;
797 bfd_release (abfd, (PTR) mapdata); /* Don't need it any more. */
799 if (bfd_read ((PTR) int_buf, 1, 4, abfd) != 4)
801 bfd_error = malformed_archive;
804 /* It seems that all numeric information in a coff archive is always
805 in big endian format, nomatter the host or target. */
807 nsymz = bfd_getb32 ((PTR) int_buf);
808 stringsize = parsed_size - (4 * nsymz) - 4;
811 /* ... except that some archive formats are broken, and it may be our
812 fault - the i960 little endian coff sometimes has big and sometimes
813 little, because our tools changed. Here's a horrible hack to clean
816 if (stringsize > 0xfffff)
818 /* This looks dangerous, let's do it the other way around */
819 nsymz = bfd_getl32 ((PTR) int_buf);
820 stringsize = parsed_size - (4 * nsymz) - 4;
825 /* The coff armap must be read sequentially. So we construct a
826 bsd-style one in core all at once, for simplicity. */
828 carsym_size = (nsymz * sizeof (carsym));
829 ptrsize = (4 * nsymz);
831 ardata->symdefs = (carsym *) bfd_zalloc (abfd, carsym_size + stringsize + 1);
832 if (ardata->symdefs == NULL)
834 bfd_error = no_memory;
837 carsyms = ardata->symdefs;
838 stringbase = ((char *) ardata->symdefs) + carsym_size;
840 /* Allocate and read in the raw offsets. */
841 raw_armap = (int *) bfd_alloc (abfd, ptrsize);
842 if (raw_armap == NULL)
844 bfd_error = no_memory;
845 goto release_symdefs;
847 if (bfd_read ((PTR) raw_armap, 1, ptrsize, abfd) != ptrsize
848 || bfd_read ((PTR) stringbase, 1, stringsize, abfd) != stringsize)
850 bfd_error = malformed_archive;
851 goto release_raw_armap;
854 /* OK, build the carsyms */
855 for (i = 0; i < nsymz; i++)
857 rawptr = raw_armap + i;
858 carsyms->file_offset = swap ((PTR) rawptr);
859 carsyms->name = stringbase;
860 stringbase += strlen (stringbase) + 1;
865 ardata->symdef_count = nsymz;
866 ardata->first_file_filepos = bfd_tell (abfd);
867 /* Pad to an even boundary if you have to */
868 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
870 bfd_has_map (abfd) = true;
871 bfd_release (abfd, (PTR) raw_armap);
875 bfd_release (abfd, (PTR) raw_armap);
877 bfd_release (abfd, (PTR) (ardata)->symdefs);
881 /* This routine can handle either coff-style or bsd-style armaps.
882 Returns false on error, true otherwise */
885 bfd_slurp_armap (abfd)
889 int i = bfd_read ((PTR) nextname, 1, 16, abfd);
896 bfd_seek (abfd, (file_ptr) - 16, SEEK_CUR);
898 if (!strncmp (nextname, "__.SYMDEF ", 16))
899 return do_slurp_bsd_armap (abfd);
900 else if (!strncmp (nextname, "/ ", 16))
901 return do_slurp_coff_armap (abfd);
903 bfd_has_map (abfd) = false;
907 /* Returns false on error, true otherwise */
908 /* flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
909 header is in a slightly different order and the map name is '/'.
910 This flavour is used by hp300hpux. */
912 #define HPUX_SYMDEF_COUNT_SIZE 2
915 bfd_slurp_bsd_armap_f2 (abfd)
918 struct areltdata *mapdata;
920 unsigned int counter;
921 bfd_byte *raw_armap, *rbase;
922 struct artdata *ardata = bfd_ardata (abfd);
924 unsigned int stringsize;
926 int i = bfd_read ((PTR) nextname, 1, 16, abfd);
933 /* The archive has at least 16 bytes in it */
934 bfd_seek (abfd, -16L, SEEK_CUR);
936 if (!strncmp (nextname, "__.SYMDEF ", 16))
937 return do_slurp_bsd_armap (abfd);
939 if (strncmp (nextname, "/ ", 16))
941 bfd_has_map (abfd) = false;
945 mapdata = _bfd_snarf_ar_hdr (abfd);
949 raw_armap = (bfd_byte *) bfd_zalloc (abfd, mapdata->parsed_size);
950 if (raw_armap == NULL)
952 bfd_error = no_memory;
954 bfd_release (abfd, (PTR) mapdata);
958 if (bfd_read ((PTR) raw_armap, 1, mapdata->parsed_size, abfd) !=
959 mapdata->parsed_size)
961 bfd_error = malformed_archive;
963 bfd_release (abfd, (PTR) raw_armap);
967 ardata->symdef_count = bfd_h_get_16 (abfd, (PTR) raw_armap);
969 if (ardata->symdef_count * BSD_SYMDEF_SIZE
970 > mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE)
972 /* Probably we're using the wrong byte ordering. */
973 bfd_error = wrong_format;
979 stringsize = bfd_h_get_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE);
980 /* skip sym count and string sz */
981 stringbase = ((char *) raw_armap
982 + HPUX_SYMDEF_COUNT_SIZE
983 + BSD_STRING_COUNT_SIZE);
984 rbase = (bfd_byte *) stringbase + stringsize;
985 ardata->symdefs = (carsym *) bfd_alloc (abfd,
986 (ardata->symdef_count
989 for (counter = 0, set = ardata->symdefs;
990 counter < ardata->symdef_count;
991 counter++, set++, rbase += BSD_SYMDEF_SIZE)
993 set->name = bfd_h_get_32 (abfd, rbase) + stringbase;
994 set->file_offset = bfd_h_get_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
997 ardata->first_file_filepos = bfd_tell (abfd);
998 /* Pad to an even boundary if you have to */
999 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1000 /* FIXME, we should provide some way to free raw_ardata when
1001 we are done using the strings from it. For now, it seems
1002 to be allocated on an obstack anyway... */
1003 bfd_has_map (abfd) = true;
1007 /** Extended name table.
1009 Normally archives support only 14-character filenames.
1011 Intel has extended the format: longer names are stored in a special
1012 element (the first in the archive, or second if there is an armap);
1013 the name in the ar_hdr is replaced by <space><index into filename
1014 element>. Index is the P.R. of an int (decimal). Data General have
1015 extended the format by using the prefix // for the special element */
1017 /* Returns false on error, true otherwise */
1019 _bfd_slurp_extended_name_table (abfd)
1023 struct areltdata *namedata;
1025 /* FIXME: Formatting sucks here, and in case of failure of BFD_READ,
1026 we probably don't want to return true. */
1027 if (bfd_read ((PTR) nextname, 1, 16, abfd) == 16)
1030 bfd_seek (abfd, (file_ptr) - 16, SEEK_CUR);
1032 if (strncmp (nextname, "ARFILENAMES/ ", 16) != 0 &&
1033 strncmp (nextname, "// ", 16) != 0)
1035 bfd_ardata (abfd)->extended_names = NULL;
1039 namedata = _bfd_snarf_ar_hdr (abfd);
1040 if (namedata == NULL)
1043 bfd_ardata (abfd)->extended_names =
1044 bfd_zalloc (abfd, namedata->parsed_size);
1045 if (bfd_ardata (abfd)->extended_names == NULL)
1047 bfd_error = no_memory;
1049 bfd_release (abfd, (PTR) namedata);
1053 if (bfd_read ((PTR) bfd_ardata (abfd)->extended_names, 1,
1054 namedata->parsed_size, abfd) != namedata->parsed_size)
1056 bfd_error = malformed_archive;
1057 bfd_release (abfd, (PTR) (bfd_ardata (abfd)->extended_names));
1058 bfd_ardata (abfd)->extended_names = NULL;
1062 /* Since the archive is supposed to be printable if it contains
1063 text, the entries in the list are newline-padded, not null
1064 padded. In SVR4-style archives, the names also have a
1065 trailing '/'. We'll fix both problems here.. */
1067 char *temp = bfd_ardata (abfd)->extended_names;
1068 char *limit = temp + namedata->parsed_size;
1069 for (; temp < limit; ++temp)
1070 if (*temp == '\012')
1071 temp[temp[-1] == '/' ? -1 : 0] = '\0';
1074 /* Pad to an even boundary if you have to */
1075 bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd);
1076 bfd_ardata (abfd)->first_file_filepos +=
1077 (bfd_ardata (abfd)->first_file_filepos) % 2;
1079 /* FIXME, we can't release namedata here because it was allocated
1080 below extended_names on the obstack... */
1081 /* bfd_release (abfd, namedata); */
1088 /* Return a copy of the stuff in the filename between any :]> and a
1098 first = file + strlen (file) - 1;
1101 while (first != file)
1105 if (*first == ':' || *first == ']' || *first == '>')
1114 copy = bfd_xmalloc (last - first + 1);
1115 memcpy (copy, first, last - first);
1116 copy[last - first] = 0;
1126 CONST char *filename = strrchr (file, '/');
1128 if (filename != (char *) NULL)
1136 /* Follows archive_head and produces an extended name table if
1137 necessary. Returns (in tabloc) a pointer to an extended name
1138 table, and in tablen the length of the table. If it makes an entry
1139 it clobbers the filename so that the element may be written without
1140 further massage. Returns true if it ran successfully, false if
1141 something went wrong. A successful return may still involve a
1142 zero-length tablen! */
1145 bfd_construct_extended_name_table (abfd, tabloc, tablen)
1148 unsigned int *tablen;
1150 unsigned int maxname = abfd->xvec->ar_max_namelen;
1151 unsigned int total_namelen = 0;
1157 /* Figure out how long the table should be */
1158 for (current = abfd->archive_head; current != NULL; current = current->next)
1160 unsigned int thislen = strlen (normalize (current->filename));
1161 if (thislen > maxname)
1162 total_namelen += thislen + 1; /* leave room for \n */
1165 if (total_namelen == 0)
1168 *tabloc = bfd_zalloc (abfd, total_namelen);
1169 if (*tabloc == NULL)
1171 bfd_error = no_memory;
1175 *tablen = total_namelen;
1178 for (current = abfd->archive_head; current != NULL; current =
1181 CONST char *normal = normalize (current->filename);
1182 unsigned int thislen = strlen (normal);
1183 if (thislen > maxname)
1185 /* Works for now; may need to be re-engineered if we
1186 encounter an oddball archive format and want to
1187 generalise this hack. */
1188 struct ar_hdr *hdr = arch_hdr (current);
1189 strcpy (strptr, normal);
1190 strptr[thislen] = '\012';
1191 hdr->ar_name[0] = ' ';
1192 /* We know there will always be enough room (one of the few
1193 cases where you may safely use sprintf). */
1194 sprintf ((hdr->ar_name) + 1, "%-d", (unsigned) (strptr - *tabloc));
1195 /* Kinda Kludgy. We should just use the returned value of
1196 sprintf but not all implementations get this right */
1198 char *temp = hdr->ar_name + 2;
1199 for (; temp < hdr->ar_name + maxname; temp++)
1203 strptr += thislen + 1;
1210 /** A couple of functions for creating ar_hdrs */
1212 /* Takes a filename, returns an arelt_data for it, or NULL if it can't
1213 make one. The filename must refer to a filename in the filesystem.
1214 The filename field of the ar_hdr will NOT be initialized */
1216 static struct areltdata *
1217 bfd_ar_hdr_from_filesystem (abfd, filename)
1219 const char *filename;
1222 struct areltdata *ared;
1226 if (stat (filename, &status) != 0)
1228 bfd_error = system_call_error;
1232 ared = (struct areltdata *) bfd_zalloc (abfd, sizeof (struct ar_hdr) +
1233 sizeof (struct areltdata));
1236 bfd_error = no_memory;
1239 hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));
1241 /* ar headers are space padded, not null padded! */
1242 memset (hdr, ' ', sizeof (struct ar_hdr));
1244 strncpy (hdr->ar_fmag, ARFMAG, 2);
1246 /* Goddamned sprintf doesn't permit MAXIMUM field lengths */
1247 sprintf ((hdr->ar_date), "%-12ld", (long) status.st_mtime);
1248 sprintf ((hdr->ar_uid), "%ld", (long) status.st_uid);
1249 sprintf ((hdr->ar_gid), "%ld", (long) status.st_gid);
1250 sprintf ((hdr->ar_mode), "%-8o", (unsigned int) status.st_mode);
1251 sprintf ((hdr->ar_size), "%-10ld", (long) status.st_size);
1252 /* Correct for a lossage in sprintf whereby it null-terminates. I cannot
1253 understand how these C losers could design such a ramshackle bunch of
1255 temp = (char *) hdr;
1256 temp1 = temp + sizeof (struct ar_hdr) - 2;
1257 for (; temp < temp1; temp++)
1262 strncpy (hdr->ar_fmag, ARFMAG, 2);
1263 ared->parsed_size = status.st_size;
1264 ared->arch_header = (char *) hdr;
1269 /* This is magic required by the "ar" program. Since it's
1270 undocumented, it's undocumented. You may think that it would take
1271 a strong stomach to write this, and it does, but it takes even a
1272 stronger stomach to try to code around such a thing! */
1275 bfd_special_undocumented_glue (abfd, filename)
1279 struct areltdata *ar_elt = bfd_ar_hdr_from_filesystem (abfd, filename);
1282 return (struct ar_hdr *) ar_elt->arch_header;
1286 /* Analogous to stat call */
1288 bfd_generic_stat_arch_elt (abfd, buf)
1295 if (abfd->arelt_data == NULL)
1297 bfd_error = invalid_operation;
1301 hdr = arch_hdr (abfd);
1303 #define foo(arelt, stelt, size) \
1304 buf->stelt = strtol (hdr->arelt, &aloser, size); \
1305 if (aloser == hdr->arelt) return -1;
1307 foo (ar_date, st_mtime, 10);
1308 foo (ar_uid, st_uid, 10);
1309 foo (ar_gid, st_gid, 10);
1310 foo (ar_mode, st_mode, 8);
1312 buf->st_size = arch_eltdata (abfd)->parsed_size;
1318 bfd_dont_truncate_arname (abfd, pathname, arhdr)
1320 CONST char *pathname;
1323 /* FIXME: This interacts unpleasantly with ar's quick-append option.
1324 Fortunately ic960 users will never use that option. Fixing this
1325 is very hard; fortunately I know how to do it and will do so once
1326 intel's release is out the door. */
1328 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1330 CONST char *filename = normalize (pathname);
1331 int maxlen = ar_maxnamelen (abfd);
1333 length = strlen (filename);
1335 if (length <= maxlen)
1336 memcpy (hdr->ar_name, filename, length);
1338 if (length < maxlen)
1339 (hdr->ar_name)[length] = ar_padchar (abfd);
1343 bfd_bsd_truncate_arname (abfd, pathname, arhdr)
1345 CONST char *pathname;
1348 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1350 CONST char *filename = strrchr (pathname, '/');
1351 int maxlen = ar_maxnamelen (abfd);
1353 if (filename == NULL)
1354 filename = pathname;
1358 length = strlen (filename);
1360 if (length <= maxlen)
1361 memcpy (hdr->ar_name, filename, length);
1364 /* pathname: meet procrustes */
1365 memcpy (hdr->ar_name, filename, maxlen);
1369 if (length < maxlen)
1370 (hdr->ar_name)[length] = ar_padchar (abfd);
1373 /* Store name into ar header. Truncates the name to fit.
1374 1> strip pathname to be just the basename.
1375 2> if it's short enuf to fit, stuff it in.
1376 3> If it doesn't end with .o, truncate it to fit
1377 4> truncate it before the .o, append .o, stuff THAT in. */
1379 /* This is what gnu ar does. It's better but incompatible with the
1383 bfd_gnu_truncate_arname (abfd, pathname, arhdr)
1385 CONST char *pathname;
1388 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1390 CONST char *filename = strrchr (pathname, '/');
1391 int maxlen = ar_maxnamelen (abfd);
1393 if (filename == NULL)
1394 filename = pathname;
1398 length = strlen (filename);
1400 if (length <= maxlen)
1401 memcpy (hdr->ar_name, filename, length);
1403 { /* pathname: meet procrustes */
1404 memcpy (hdr->ar_name, filename, maxlen);
1405 if ((filename[length - 2] == '.') && (filename[length - 1] == 'o'))
1407 hdr->ar_name[maxlen - 2] = '.';
1408 hdr->ar_name[maxlen - 1] = 'o';
1414 (hdr->ar_name)[length] = ar_padchar (abfd);
1417 /* The BFD is open for write and has its format set to bfd_archive */
1420 _bfd_write_archive_contents (arch)
1424 char *etable = NULL;
1425 unsigned int elength = 0;
1426 boolean makemap = bfd_has_map (arch);
1427 boolean hasobjects = false; /* if no .o's, don't bother to make a map */
1431 /* Verify the viability of all entries; if any of them live in the
1432 filesystem (as opposed to living in an archive open for input)
1433 then construct a fresh ar_hdr for them. */
1434 for (current = arch->archive_head; current; current = current->next)
1436 if (bfd_write_p (current))
1438 bfd_error = invalid_operation;
1441 if (!current->arelt_data)
1443 current->arelt_data =
1444 (PTR) bfd_ar_hdr_from_filesystem (arch, current->filename);
1445 if (!current->arelt_data)
1448 /* Put in the file name */
1449 BFD_SEND (arch, _bfd_truncate_arname, (arch,
1451 (char *) arch_hdr (current)));
1455 { /* don't bother if we won't make a map! */
1456 if ((bfd_check_format (current, bfd_object))
1457 #if 0 /* FIXME -- these are not set correctly */
1458 && ((bfd_get_file_flags (current) & HAS_SYMS))
1465 if (!bfd_construct_extended_name_table (arch, &etable, &elength))
1468 bfd_seek (arch, (file_ptr) 0, SEEK_SET);
1470 bfd_write (BFD_GNU960_ARMAG (arch), 1, SARMAG, arch);
1472 bfd_write (ARMAG, 1, SARMAG, arch);
1475 if (makemap && hasobjects)
1477 if (compute_and_write_armap (arch, elength) != true)
1485 memset ((char *) (&hdr), 0, sizeof (struct ar_hdr));
1486 sprintf (&(hdr.ar_name[0]), "ARFILENAMES/");
1487 sprintf (&(hdr.ar_size[0]), "%-10d", (int) elength);
1488 hdr.ar_fmag[0] = '`';
1489 hdr.ar_fmag[1] = '\012';
1490 for (i = 0; i < sizeof (struct ar_hdr); i++)
1491 if (((char *) (&hdr))[i] == '\0')
1492 (((char *) (&hdr))[i]) = ' ';
1493 bfd_write ((char *) &hdr, 1, sizeof (struct ar_hdr), arch);
1494 bfd_write (etable, 1, elength, arch);
1495 if ((elength % 2) == 1)
1496 bfd_write ("\012", 1, 1, arch);
1499 for (current = arch->archive_head; current; current = current->next)
1501 char buffer[DEFAULT_BUFFERSIZE];
1502 unsigned int remaining = arelt_size (current);
1503 struct ar_hdr *hdr = arch_hdr (current);
1505 /* write ar header */
1506 if (bfd_write ((char *) hdr, 1, sizeof (*hdr), arch) != sizeof (*hdr))
1509 bfd_error = system_call_error;
1512 if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
1516 unsigned int amt = DEFAULT_BUFFERSIZE;
1517 if (amt > remaining)
1520 if (bfd_read (buffer, amt, 1, current) != amt)
1524 /* Looks like a truncated archive. */
1525 bfd_error = malformed_archive;
1528 if (bfd_write (buffer, amt, 1, arch) != amt)
1532 if ((arelt_size (current) % 2) == 1)
1533 bfd_write ("\012", 1, 1, arch);
1536 /* Verify the timestamp in the archive file. If it would not be
1537 accepted by the linker, rewrite it until it would be. If
1538 anything odd happens, break out and just return. (The Berkeley
1539 linker checks the timestamp and refuses to read the
1540 table-of-contents if it is >60 seconds less than the file's
1541 modified-time. That painful hack requires this painful hack. */
1546 /* FIXME! This kludge is to avoid adding a member to the xvec,
1547 while generating a small patch for Adobe. FIXME! The
1548 update_armap_timestamp function call should be in the xvec,
1551 if (bfd_update_armap_timestamp (arch) == true) break;
1554 Instead, we check whether in a BSD archive, and call
1557 if (arch->xvec->write_armap != bsd_write_armap)
1559 if (bsd_update_armap_timestamp (arch) == true) /* FIXME!!! Vector it */
1563 "Warning: writing archive was slow: rewriting timestamp\n");
1565 while (++tries < 6);
1570 /* Note that the namidx for the first symbol is 0 */
1573 compute_and_write_armap (arch, elength)
1575 unsigned int elength;
1579 file_ptr elt_no = 0;
1581 int orl_max = 1024; /* fine initial default */
1583 int stridx = 0; /* string index */
1584 asymbol **syms = NULL;
1585 unsigned int syms_max = 0;
1588 /* Dunno if this is the best place for this info... */
1590 elength += sizeof (struct ar_hdr);
1591 elength += elength % 2;
1593 map = (struct orl *) malloc (orl_max * sizeof (struct orl));
1596 bfd_error = no_memory;
1600 /* We put the symbol names on the arch obstack, and then discard
1602 first_name = bfd_alloc (arch, 1);
1603 if (first_name == NULL)
1606 bfd_error = no_memory;
1610 /* Drop all the files called __.SYMDEF, we're going to make our
1612 while (arch->archive_head &&
1613 strcmp (arch->archive_head->filename, "__.SYMDEF") == 0)
1614 arch->archive_head = arch->archive_head->next;
1616 /* Map over each element */
1617 for (current = arch->archive_head;
1618 current != (bfd *) NULL;
1619 current = current->next, elt_no++)
1621 if ((bfd_check_format (current, bfd_object) == true)
1622 && ((bfd_get_file_flags (current) & HAS_SYMS)))
1624 unsigned int storage;
1625 unsigned int symcount;
1626 unsigned int src_count;
1628 storage = get_symtab_upper_bound (current);
1631 if (storage > syms_max)
1636 syms = (asymbol **) malloc (syms_max);
1640 bfd_release (arch, first_name);
1641 bfd_error = no_memory;
1645 symcount = bfd_canonicalize_symtab (current, syms);
1647 /* Now map over all the symbols, picking out the ones we want */
1648 for (src_count = 0; src_count < symcount; src_count++)
1650 flagword flags = (syms[src_count])->flags;
1651 asection *sec = syms[src_count]->section;
1653 if ((flags & BSF_GLOBAL ||
1655 flags & BSF_INDIRECT ||
1656 bfd_is_com_section (sec))
1657 && (sec != &bfd_und_section))
1660 struct orl *new_map;
1662 /* This symbol will go into the archive header */
1663 if (orl_count == orl_max)
1666 new_map = ((struct orl *)
1668 orl_max * sizeof (struct orl)));
1669 if (new_map == (struct orl *) NULL)
1674 bfd_release (arch, first_name);
1675 bfd_error = no_memory;
1682 namelen = strlen (syms[src_count]->name);
1683 map[orl_count].name = ((char **)
1686 if (map[orl_count].name == NULL)
1688 *(map[orl_count].name) = bfd_alloc (arch, namelen + 1);
1689 if (*(map[orl_count].name) == NULL)
1691 strcpy (*(map[orl_count].name), syms[src_count]->name);
1692 (map[orl_count]).pos = (file_ptr) current;
1693 (map[orl_count]).namidx = stridx;
1695 stridx += namelen + 1;
1703 /* OK, now we have collected all the data, let's write them out */
1704 ret = BFD_SEND (arch, write_armap,
1705 (arch, elength, map, orl_count, stridx));
1710 bfd_release (arch, first_name);
1716 bsd_write_armap (arch, elength, map, orl_count, stridx)
1718 unsigned int elength;
1720 unsigned int orl_count;
1723 int padit = stridx & 1;
1724 unsigned int ranlibsize = orl_count * sizeof (struct ranlib);
1725 unsigned int stringsize = stridx + padit;
1726 /* Include 8 bytes to store ranlibsize and stringsize in output. */
1727 unsigned int mapsize = ranlibsize + stringsize + 8;
1729 bfd *current = arch->archive_head;
1730 bfd *last_elt = current; /* last element arch seen */
1734 struct stat statbuf;
1737 firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
1739 stat (arch->filename, &statbuf);
1740 memset ((char *) (&hdr), 0, sizeof (struct ar_hdr));
1741 sprintf (hdr.ar_name, RANLIBMAG);
1742 /* Remember the timestamp, to keep it holy. But fudge it a little. */
1743 bfd_ardata (arch)->armap_timestamp = statbuf.st_mtime + ARMAP_TIME_OFFSET;
1744 bfd_ardata (arch)->armap_datepos = (SARMAG
1745 + offsetof (struct ar_hdr, ar_date[0]));
1746 sprintf (hdr.ar_date, "%ld", bfd_ardata (arch)->armap_timestamp);
1747 sprintf (hdr.ar_uid, "%d", getuid ());
1748 sprintf (hdr.ar_gid, "%d", getgid ());
1749 sprintf (hdr.ar_size, "%-10d", (int) mapsize);
1750 hdr.ar_fmag[0] = '`';
1751 hdr.ar_fmag[1] = '\012';
1752 for (i = 0; i < sizeof (struct ar_hdr); i++)
1753 if (((char *) (&hdr))[i] == '\0')
1754 (((char *) (&hdr))[i]) = ' ';
1755 bfd_write ((char *) &hdr, 1, sizeof (struct ar_hdr), arch);
1756 bfd_h_put_32 (arch, (bfd_vma) ranlibsize, (PTR) &temp);
1757 bfd_write (&temp, 1, sizeof (temp), arch);
1759 for (count = 0; count < orl_count; count++)
1762 struct symdef *outp = &outs;
1764 if (((bfd *) (map[count]).pos) != last_elt)
1768 firstreal += arelt_size (current) + sizeof (struct ar_hdr);
1769 firstreal += firstreal % 2;
1770 current = current->next;
1772 while (current != (bfd *) (map[count]).pos);
1773 } /* if new archive element */
1776 bfd_h_put_32 (arch, ((map[count]).namidx), (PTR) &outs.s.string_offset);
1777 bfd_h_put_32 (arch, firstreal, (PTR) &outs.file_offset);
1778 bfd_write ((char *) outp, 1, sizeof (outs), arch);
1781 /* now write the strings themselves */
1782 bfd_h_put_32 (arch, stringsize, (PTR) &temp);
1783 bfd_write ((PTR) &temp, 1, sizeof (temp), arch);
1784 for (count = 0; count < orl_count; count++)
1785 bfd_write (*((map[count]).name), 1,
1786 strlen (*((map[count]).name)) + 1, arch);
1788 /* The spec sez this should be a newline. But in order to be
1789 bug-compatible for sun's ar we use a null. */
1791 bfd_write ("", 1, 1, arch);
1796 /* At the end of archive file handling, update the timestamp in the
1797 file, so the linker will accept it.
1799 Return true if the timestamp was OK, or an unusual problem happened.
1800 Return false if we updated the timestamp. */
1803 bsd_update_armap_timestamp (arch)
1806 struct stat archstat;
1810 /* Flush writes, get last-write timestamp from file, and compare it
1811 to the timestamp IN the file. */
1813 if (bfd_stat (arch, &archstat) == -1)
1815 perror ("Reading archive file mod timestamp");
1816 return true; /* Can't read mod time for some reason */
1818 if (archstat.st_mtime <= bfd_ardata (arch)->armap_timestamp)
1819 return true; /* OK by the linker's rules */
1821 /* Update the timestamp. */
1822 bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET;
1824 /* Prepare an ASCII version suitable for writing. */
1825 memset (hdr.ar_date, 0, sizeof (hdr.ar_date));
1826 sprintf (hdr.ar_date, "%ld", bfd_ardata (arch)->armap_timestamp);
1827 for (i = 0; i < sizeof (hdr.ar_date); i++)
1828 if (hdr.ar_date[i] == '\0')
1829 (hdr.ar_date)[i] = ' ';
1831 /* Write it into the file. */
1832 bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET);
1833 if (bfd_write (hdr.ar_date, sizeof (hdr.ar_date), 1, arch)
1834 != sizeof (hdr.ar_date))
1836 perror ("Writing updated armap timestamp");
1837 return true; /* Some error while writing */
1840 return false; /* We updated the timestamp successfully. */
1843 /* A coff armap looks like :
1845 struct ar_hdr with name = '/'
1847 offset of file for symbol 0
1848 offset of file for symbol 1
1850 offset of file for symbol n-1
1858 coff_write_armap (arch, elength, map, symbol_count, stridx)
1860 unsigned int elength;
1862 unsigned int symbol_count;
1865 /* The size of the ranlib is the number of exported symbols in the
1866 archive * the number of bytes in a int, + an int for the count */
1867 unsigned int ranlibsize = (symbol_count * 4) + 4;
1868 unsigned int stringsize = stridx;
1869 unsigned int mapsize = stringsize + ranlibsize;
1870 file_ptr archive_member_file_ptr;
1871 bfd *current = arch->archive_head;
1875 int padit = mapsize & 1;
1880 /* work out where the first object file will go in the archive */
1881 archive_member_file_ptr = (mapsize
1883 + sizeof (struct ar_hdr)
1886 memset ((char *) (&hdr), 0, sizeof (struct ar_hdr));
1887 hdr.ar_name[0] = '/';
1888 sprintf (hdr.ar_size, "%-10d", (int) mapsize);
1889 sprintf (hdr.ar_date, "%ld", (long) time (NULL));
1890 /* This, at least, is what Intel coff sets the values to.: */
1891 sprintf ((hdr.ar_uid), "%d", 0);
1892 sprintf ((hdr.ar_gid), "%d", 0);
1893 sprintf ((hdr.ar_mode), "%-7o", (unsigned) 0);
1894 hdr.ar_fmag[0] = '`';
1895 hdr.ar_fmag[1] = '\012';
1897 for (i = 0; i < sizeof (struct ar_hdr); i++)
1898 if (((char *) (&hdr))[i] == '\0')
1899 (((char *) (&hdr))[i]) = ' ';
1901 /* Write the ar header for this item and the number of symbols */
1903 bfd_write ((PTR) &hdr, 1, sizeof (struct ar_hdr), arch);
1905 bfd_write_bigendian_4byte_int (arch, symbol_count);
1907 /* Two passes, first write the file offsets for each symbol -
1908 remembering that each offset is on a two byte boundary. */
1910 /* Write out the file offset for the file associated with each
1911 symbol, and remember to keep the offsets padded out. */
1913 current = arch->archive_head;
1915 while (current != (bfd *) NULL && count < symbol_count)
1917 /* For each symbol which is used defined in this object, write out
1918 the object file's address in the archive */
1920 while (((bfd *) (map[count]).pos) == current)
1922 bfd_write_bigendian_4byte_int (arch, archive_member_file_ptr);
1925 /* Add size of this archive entry */
1926 archive_member_file_ptr += (arelt_size (current)
1927 + sizeof (struct ar_hdr));
1928 /* remember aboout the even alignment */
1929 archive_member_file_ptr += archive_member_file_ptr % 2;
1930 current = current->next;
1933 /* now write the strings themselves */
1934 for (count = 0; count < symbol_count; count++)
1935 bfd_write ((PTR) * ((map[count]).name),
1937 strlen (*((map[count]).name)) + 1, arch);
1939 /* The spec sez this should be a newline. But in order to be
1940 bug-compatible for arc960 we use a null. */
1942 bfd_write ("", 1, 1, arch);