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 /* Returns false on error, true otherwise */
689 do_slurp_bsd_armap (abfd
)
692 struct areltdata
*mapdata
;
693 unsigned int counter
= 0;
694 int *raw_armap
, *rbase
;
695 struct artdata
*ardata
= bfd_ardata (abfd
);
697 unsigned int parsed_size
;
699 mapdata
= _bfd_snarf_ar_hdr (abfd
);
702 parsed_size
= mapdata
->parsed_size
;
703 bfd_release (abfd
, (PTR
) mapdata
); /* Don't need it any more. */
705 raw_armap
= (int *) bfd_zalloc (abfd
, parsed_size
);
706 if (raw_armap
== NULL
)
708 bfd_error
= no_memory
;
712 if (bfd_read ((PTR
) raw_armap
, 1, parsed_size
, abfd
) != parsed_size
)
714 bfd_error
= malformed_archive
;
716 bfd_release (abfd
, (PTR
) raw_armap
);
720 ardata
->symdef_count
= (bfd_h_get_32 (abfd
, (bfd_byte
*) raw_armap
)
721 / sizeof (struct symdef
));
723 if (ardata
->symdef_count
* sizeof (struct symdef
)
724 > parsed_size
- sizeof (*raw_armap
))
726 /* Probably we're using the wrong byte ordering. */
727 bfd_error
= wrong_format
;
732 rbase
= raw_armap
+ 1;
733 ardata
->symdefs
= (carsym
*) rbase
;
734 stringbase
= ((char *) (ardata
->symdefs
+ ardata
->symdef_count
)) + 4;
736 for (; counter
< ardata
->symdef_count
; counter
++)
738 struct symdef
*sym
= ((struct symdef
*) rbase
) + counter
;
739 sym
->s
.name
= (bfd_h_get_32 (abfd
, (bfd_byte
*) (&sym
->s
.string_offset
))
741 sym
->file_offset
= bfd_h_get_32 (abfd
,
742 (bfd_byte
*) (&(sym
->file_offset
)));
745 ardata
->first_file_filepos
= bfd_tell (abfd
);
746 /* Pad to an even boundary if you have to */
747 ardata
->first_file_filepos
+= (ardata
->first_file_filepos
) % 2;
748 /* FIXME, we should provide some way to free raw_ardata when
749 we are done using the strings from it. For now, it seems
750 to be allocated on an obstack anyway... */
751 bfd_has_map (abfd
) = true;
755 /* Returns false on error, true otherwise */
757 do_slurp_coff_armap (abfd
)
760 struct areltdata
*mapdata
;
761 int *raw_armap
, *rawptr
;
762 struct artdata
*ardata
= bfd_ardata (abfd
);
764 unsigned int stringsize
;
765 unsigned int parsed_size
;
767 unsigned int nsymz
; /* Number of symbols in armap. */
768 bfd_vma (*swap
) PARAMS ((const bfd_byte
*));
769 char int_buf
[sizeof (long)];
770 unsigned int carsym_size
, ptrsize
, i
;
772 mapdata
= _bfd_snarf_ar_hdr (abfd
);
775 parsed_size
= mapdata
->parsed_size
;
776 bfd_release (abfd
, (PTR
) mapdata
); /* Don't need it any more. */
778 if (bfd_read ((PTR
) int_buf
, 1, 4, abfd
) != 4)
780 bfd_error
= malformed_archive
;
783 /* It seems that all numeric information in a coff archive is always
784 in big endian format, nomatter the host or target. */
786 nsymz
= bfd_getb32 ((PTR
) int_buf
);
787 stringsize
= parsed_size
- (4 * nsymz
) - 4;
790 /* ... except that some archive formats are broken, and it may be our
791 fault - the i960 little endian coff sometimes has big and sometimes
792 little, because our tools changed. Here's a horrible hack to clean
795 if (stringsize
> 0xfffff)
797 /* This looks dangerous, let's do it the other way around */
798 nsymz
= bfd_getl32 ((PTR
) int_buf
);
799 stringsize
= parsed_size
- (4 * nsymz
) - 4;
804 /* The coff armap must be read sequentially. So we construct a
805 bsd-style one in core all at once, for simplicity. */
807 carsym_size
= (nsymz
* sizeof (carsym
));
808 ptrsize
= (4 * nsymz
);
810 ardata
->symdefs
= (carsym
*) bfd_zalloc (abfd
, carsym_size
+ stringsize
+ 1);
811 if (ardata
->symdefs
== NULL
)
813 bfd_error
= no_memory
;
816 carsyms
= ardata
->symdefs
;
817 stringbase
= ((char *) ardata
->symdefs
) + carsym_size
;
819 /* Allocate and read in the raw offsets. */
820 raw_armap
= (int *) bfd_alloc (abfd
, ptrsize
);
821 if (raw_armap
== NULL
)
823 bfd_error
= no_memory
;
824 goto release_symdefs
;
826 if (bfd_read ((PTR
) raw_armap
, 1, ptrsize
, abfd
) != ptrsize
827 || bfd_read ((PTR
) stringbase
, 1, stringsize
, abfd
) != stringsize
)
829 bfd_error
= malformed_archive
;
830 goto release_raw_armap
;
833 /* OK, build the carsyms */
834 for (i
= 0; i
< nsymz
; i
++)
836 rawptr
= raw_armap
+ i
;
837 carsyms
->file_offset
= swap ((PTR
) rawptr
);
838 carsyms
->name
= stringbase
;
839 stringbase
+= strlen (stringbase
) + 1;
844 ardata
->symdef_count
= nsymz
;
845 ardata
->first_file_filepos
= bfd_tell (abfd
);
846 /* Pad to an even boundary if you have to */
847 ardata
->first_file_filepos
+= (ardata
->first_file_filepos
) % 2;
849 bfd_has_map (abfd
) = true;
850 bfd_release (abfd
, (PTR
) raw_armap
);
854 bfd_release (abfd
, (PTR
) raw_armap
);
856 bfd_release (abfd
, (PTR
) (ardata
)->symdefs
);
860 /* This routine can handle either coff-style or bsd-style armaps.
861 Returns false on error, true otherwise */
864 bfd_slurp_armap (abfd
)
868 int i
= bfd_read ((PTR
) nextname
, 1, 16, abfd
);
875 bfd_seek (abfd
, (file_ptr
) - 16, SEEK_CUR
);
877 if (!strncmp (nextname
, "__.SYMDEF ", 16))
878 return do_slurp_bsd_armap (abfd
);
879 else if (!strncmp (nextname
, "/ ", 16))
880 return do_slurp_coff_armap (abfd
);
882 bfd_has_map (abfd
) = false;
886 /* Returns false on error, true otherwise */
887 /* flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
888 header is in a slightly different order and the map name is '/'.
889 This flavour is used by hp300hpux. */
891 bfd_slurp_bsd_armap_f2 (abfd
)
894 struct areltdata
*mapdata
;
896 unsigned int counter
= 0;
897 int *raw_armap
, *rbase
;
898 struct artdata
*ardata
= bfd_ardata (abfd
);
900 unsigned int stringsize
;
901 int i
= bfd_read ((PTR
) nextname
, 1, 16, abfd
);
908 /* The archive has at least 16 bytes in it */
909 bfd_seek (abfd
, -16L, SEEK_CUR
);
911 if (!strncmp (nextname
, "__.SYMDEF ", 16))
912 return do_slurp_bsd_armap (abfd
);
914 if (strncmp (nextname
, "/ ", 16))
916 bfd_has_map (abfd
) = false;
920 mapdata
= _bfd_snarf_ar_hdr (abfd
);
924 raw_armap
= (int *) bfd_zalloc (abfd
, mapdata
->parsed_size
);
925 if (raw_armap
== NULL
)
927 bfd_error
= no_memory
;
929 bfd_release (abfd
, (PTR
) mapdata
);
933 if (bfd_read ((PTR
) raw_armap
, 1, mapdata
->parsed_size
, abfd
) !=
934 mapdata
->parsed_size
)
936 bfd_error
= malformed_archive
;
938 bfd_release (abfd
, (PTR
) raw_armap
);
942 ardata
->symdef_count
= bfd_h_get_16 (abfd
, (PTR
) raw_armap
);
944 if (ardata
->symdef_count
* sizeof (struct symdef
)
945 > mapdata
->parsed_size
- sizeof (*raw_armap
))
947 /* Probably we're using the wrong byte ordering. */
948 bfd_error
= wrong_format
;
954 stringsize
= bfd_h_get_32 (abfd
, (PTR
) (((char *) raw_armap
) + 2));
955 /* skip sym count and string sz */
956 rbase
= (int *) (((char *) raw_armap
) + 6);
957 stringbase
= (char *) rbase
;
958 ardata
->symdefs
= (carsym
*) (((char *) rbase
) + stringsize
);
960 for (; counter
< ardata
->symdef_count
; counter
++)
962 struct symdef
*sym
= ((struct symdef
*) ardata
->symdefs
) + counter
;
963 sym
->s
.name
= (bfd_h_get_32 (abfd
, (PTR
) (&(sym
->s
.string_offset
)))
965 sym
->file_offset
= bfd_h_get_32 (abfd
, (PTR
) (&(sym
->file_offset
)));
968 ardata
->first_file_filepos
= bfd_tell (abfd
);
969 /* Pad to an even boundary if you have to */
970 ardata
->first_file_filepos
+= (ardata
->first_file_filepos
) % 2;
971 /* FIXME, we should provide some way to free raw_ardata when
972 we are done using the strings from it. For now, it seems
973 to be allocated on an obstack anyway... */
974 bfd_has_map (abfd
) = true;
978 /** Extended name table.
980 Normally archives support only 14-character filenames.
982 Intel has extended the format: longer names are stored in a special
983 element (the first in the archive, or second if there is an armap);
984 the name in the ar_hdr is replaced by <space><index into filename
985 element>. Index is the P.R. of an int (decimal). Data General have
986 extended the format by using the prefix // for the special element */
988 /* Returns false on error, true otherwise */
990 _bfd_slurp_extended_name_table (abfd
)
994 struct areltdata
*namedata
;
996 /* FIXME: Formatting sucks here, and in case of failure of BFD_READ,
997 we probably don't want to return true. */
998 if (bfd_read ((PTR
) nextname
, 1, 16, abfd
) == 16)
1001 bfd_seek (abfd
, (file_ptr
) - 16, SEEK_CUR
);
1003 if (strncmp (nextname
, "ARFILENAMES/ ", 16) != 0 &&
1004 strncmp (nextname
, "// ", 16) != 0)
1006 bfd_ardata (abfd
)->extended_names
= NULL
;
1010 namedata
= _bfd_snarf_ar_hdr (abfd
);
1011 if (namedata
== NULL
)
1014 bfd_ardata (abfd
)->extended_names
=
1015 bfd_zalloc (abfd
, namedata
->parsed_size
);
1016 if (bfd_ardata (abfd
)->extended_names
== NULL
)
1018 bfd_error
= no_memory
;
1020 bfd_release (abfd
, (PTR
) namedata
);
1024 if (bfd_read ((PTR
) bfd_ardata (abfd
)->extended_names
, 1,
1025 namedata
->parsed_size
, abfd
) != namedata
->parsed_size
)
1027 bfd_error
= malformed_archive
;
1028 bfd_release (abfd
, (PTR
) (bfd_ardata (abfd
)->extended_names
));
1029 bfd_ardata (abfd
)->extended_names
= NULL
;
1033 /* Since the archive is supposed to be printable if it contains
1034 text, the entries in the list are newline-padded, not null
1035 padded. In SVR4-style archives, the names also have a
1036 trailing '/'. We'll fix both problems here.. */
1038 char *temp
= bfd_ardata (abfd
)->extended_names
;
1039 char *limit
= temp
+ namedata
->parsed_size
;
1040 for (; temp
< limit
; ++temp
)
1042 temp
[temp
[-1] == '/' ? -1 : 0] = '\0';
1045 /* Pad to an even boundary if you have to */
1046 bfd_ardata (abfd
)->first_file_filepos
= bfd_tell (abfd
);
1047 bfd_ardata (abfd
)->first_file_filepos
+=
1048 (bfd_ardata (abfd
)->first_file_filepos
) % 2;
1050 /* FIXME, we can't release namedata here because it was allocated
1051 below extended_names on the obstack... */
1052 /* bfd_release (abfd, namedata); */
1059 /* Return a copy of the stuff in the filename between any :]> and a
1069 first
= file
+ strlen (file
) - 1;
1072 while (first
!= file
)
1076 if (*first
== ':' || *first
== ']' || *first
== '>')
1085 copy
= bfd_xmalloc (last
- first
+ 1);
1086 memcpy (copy
, first
, last
- first
);
1087 copy
[last
- first
] = 0;
1097 CONST
char *filename
= strrchr (file
, '/');
1099 if (filename
!= (char *) NULL
)
1107 /* Follows archive_head and produces an extended name table if
1108 necessary. Returns (in tabloc) a pointer to an extended name
1109 table, and in tablen the length of the table. If it makes an entry
1110 it clobbers the filename so that the element may be written without
1111 further massage. Returns true if it ran successfully, false if
1112 something went wrong. A successful return may still involve a
1113 zero-length tablen! */
1116 bfd_construct_extended_name_table (abfd
, tabloc
, tablen
)
1119 unsigned int *tablen
;
1121 unsigned int maxname
= abfd
->xvec
->ar_max_namelen
;
1122 unsigned int total_namelen
= 0;
1128 /* Figure out how long the table should be */
1129 for (current
= abfd
->archive_head
; current
!= NULL
; current
= current
->next
)
1131 unsigned int thislen
= strlen (normalize (current
->filename
));
1132 if (thislen
> maxname
)
1133 total_namelen
+= thislen
+ 1; /* leave room for \n */
1136 if (total_namelen
== 0)
1139 *tabloc
= bfd_zalloc (abfd
, total_namelen
);
1140 if (*tabloc
== NULL
)
1142 bfd_error
= no_memory
;
1146 *tablen
= total_namelen
;
1149 for (current
= abfd
->archive_head
; current
!= NULL
; current
=
1152 CONST
char *normal
= normalize (current
->filename
);
1153 unsigned int thislen
= strlen (normal
);
1154 if (thislen
> maxname
)
1156 /* Works for now; may need to be re-engineered if we
1157 encounter an oddball archive format and want to
1158 generalise this hack. */
1159 struct ar_hdr
*hdr
= arch_hdr (current
);
1160 strcpy (strptr
, normal
);
1161 strptr
[thislen
] = '\n';
1162 hdr
->ar_name
[0] = ' ';
1163 /* We know there will always be enough room (one of the few
1164 cases where you may safely use sprintf). */
1165 sprintf ((hdr
->ar_name
) + 1, "%-d", (unsigned) (strptr
- *tabloc
));
1166 /* Kinda Kludgy. We should just use the returned value of
1167 sprintf but not all implementations get this right */
1169 char *temp
= hdr
->ar_name
+ 2;
1170 for (; temp
< hdr
->ar_name
+ maxname
; temp
++)
1174 strptr
+= thislen
+ 1;
1181 /** A couple of functions for creating ar_hdrs */
1183 /* Takes a filename, returns an arelt_data for it, or NULL if it can't
1184 make one. The filename must refer to a filename in the filesystem.
1185 The filename field of the ar_hdr will NOT be initialized */
1187 static struct areltdata
*
1188 bfd_ar_hdr_from_filesystem (abfd
, filename
)
1190 const char *filename
;
1193 struct areltdata
*ared
;
1197 if (stat (filename
, &status
) != 0)
1199 bfd_error
= system_call_error
;
1203 ared
= (struct areltdata
*) bfd_zalloc (abfd
, sizeof (struct ar_hdr
) +
1204 sizeof (struct areltdata
));
1207 bfd_error
= no_memory
;
1210 hdr
= (struct ar_hdr
*) (((char *) ared
) + sizeof (struct areltdata
));
1212 /* ar headers are space padded, not null padded! */
1213 memset (hdr
, ' ', sizeof (struct ar_hdr
));
1215 strncpy (hdr
->ar_fmag
, ARFMAG
, 2);
1217 /* Goddamned sprintf doesn't permit MAXIMUM field lengths */
1218 sprintf ((hdr
->ar_date
), "%-12ld", status
.st_mtime
);
1219 sprintf ((hdr
->ar_uid
), "%d", status
.st_uid
);
1220 sprintf ((hdr
->ar_gid
), "%d", status
.st_gid
);
1221 sprintf ((hdr
->ar_mode
), "%-8o", (unsigned) status
.st_mode
);
1222 sprintf ((hdr
->ar_size
), "%-10ld", status
.st_size
);
1223 /* Correct for a lossage in sprintf whereby it null-terminates. I cannot
1224 understand how these C losers could design such a ramshackle bunch of
1226 temp
= (char *) hdr
;
1227 temp1
= temp
+ sizeof (struct ar_hdr
) - 2;
1228 for (; temp
< temp1
; temp
++)
1233 strncpy (hdr
->ar_fmag
, ARFMAG
, 2);
1234 ared
->parsed_size
= status
.st_size
;
1235 ared
->arch_header
= (char *) hdr
;
1240 /* This is magic required by the "ar" program. Since it's
1241 undocumented, it's undocumented. You may think that it would take
1242 a strong stomach to write this, and it does, but it takes even a
1243 stronger stomach to try to code around such a thing! */
1246 bfd_special_undocumented_glue (abfd
, filename
)
1250 struct areltdata
*ar_elt
= bfd_ar_hdr_from_filesystem (abfd
, filename
);
1253 return (struct ar_hdr
*) ar_elt
->arch_header
;
1257 /* Analogous to stat call */
1259 bfd_generic_stat_arch_elt (abfd
, buf
)
1266 if (abfd
->arelt_data
== NULL
)
1268 bfd_error
= invalid_operation
;
1272 hdr
= arch_hdr (abfd
);
1274 #define foo(arelt, stelt, size) \
1275 buf->stelt = strtol (hdr->arelt, &aloser, size); \
1276 if (aloser == hdr->arelt) return -1;
1278 foo (ar_date
, st_mtime
, 10);
1279 foo (ar_uid
, st_uid
, 10);
1280 foo (ar_gid
, st_gid
, 10);
1281 foo (ar_mode
, st_mode
, 8);
1283 buf
->st_size
= arch_eltdata (abfd
)->parsed_size
;
1289 bfd_dont_truncate_arname (abfd
, pathname
, arhdr
)
1291 CONST
char *pathname
;
1294 /* FIXME: This interacts unpleasantly with ar's quick-append option.
1295 Fortunately ic960 users will never use that option. Fixing this
1296 is very hard; fortunately I know how to do it and will do so once
1297 intel's release is out the door. */
1299 struct ar_hdr
*hdr
= (struct ar_hdr
*) arhdr
;
1301 CONST
char *filename
= normalize (pathname
);
1302 int maxlen
= ar_maxnamelen (abfd
);
1304 length
= strlen (filename
);
1306 if (length
<= maxlen
)
1307 memcpy (hdr
->ar_name
, filename
, length
);
1309 if (length
< maxlen
)
1310 (hdr
->ar_name
)[length
] = ar_padchar (abfd
);
1314 bfd_bsd_truncate_arname (abfd
, pathname
, arhdr
)
1316 CONST
char *pathname
;
1319 struct ar_hdr
*hdr
= (struct ar_hdr
*) arhdr
;
1321 CONST
char *filename
= strrchr (pathname
, '/');
1322 int maxlen
= ar_maxnamelen (abfd
);
1324 if (filename
== NULL
)
1325 filename
= pathname
;
1329 length
= strlen (filename
);
1331 if (length
<= maxlen
)
1332 memcpy (hdr
->ar_name
, filename
, length
);
1335 /* pathname: meet procrustes */
1336 memcpy (hdr
->ar_name
, filename
, maxlen
);
1340 if (length
< maxlen
)
1341 (hdr
->ar_name
)[length
] = ar_padchar (abfd
);
1344 /* Store name into ar header. Truncates the name to fit.
1345 1> strip pathname to be just the basename.
1346 2> if it's short enuf to fit, stuff it in.
1347 3> If it doesn't end with .o, truncate it to fit
1348 4> truncate it before the .o, append .o, stuff THAT in. */
1350 /* This is what gnu ar does. It's better but incompatible with the
1354 bfd_gnu_truncate_arname (abfd
, pathname
, arhdr
)
1356 CONST
char *pathname
;
1359 struct ar_hdr
*hdr
= (struct ar_hdr
*) arhdr
;
1361 CONST
char *filename
= strrchr (pathname
, '/');
1362 int maxlen
= ar_maxnamelen (abfd
);
1364 if (filename
== NULL
)
1365 filename
= pathname
;
1369 length
= strlen (filename
);
1371 if (length
<= maxlen
)
1372 memcpy (hdr
->ar_name
, filename
, length
);
1374 { /* pathname: meet procrustes */
1375 memcpy (hdr
->ar_name
, filename
, maxlen
);
1376 if ((filename
[length
- 2] == '.') && (filename
[length
- 1] == 'o'))
1378 hdr
->ar_name
[maxlen
- 2] = '.';
1379 hdr
->ar_name
[maxlen
- 1] = 'o';
1385 (hdr
->ar_name
)[length
] = ar_padchar (abfd
);
1388 /* The BFD is open for write and has its format set to bfd_archive */
1391 _bfd_write_archive_contents (arch
)
1395 char *etable
= NULL
;
1396 unsigned int elength
= 0;
1397 boolean makemap
= bfd_has_map (arch
);
1398 boolean hasobjects
= false; /* if no .o's, don't bother to make a map */
1402 /* Verify the viability of all entries; if any of them live in the
1403 filesystem (as opposed to living in an archive open for input)
1404 then construct a fresh ar_hdr for them. */
1405 for (current
= arch
->archive_head
; current
; current
= current
->next
)
1407 if (bfd_write_p (current
))
1409 bfd_error
= invalid_operation
;
1412 if (!current
->arelt_data
)
1414 current
->arelt_data
=
1415 (PTR
) bfd_ar_hdr_from_filesystem (arch
, current
->filename
);
1416 if (!current
->arelt_data
)
1419 /* Put in the file name */
1420 BFD_SEND (arch
, _bfd_truncate_arname
, (arch
,
1422 (char *) arch_hdr (current
)));
1426 { /* don't bother if we won't make a map! */
1427 if ((bfd_check_format (current
, bfd_object
))
1428 #if 0 /* FIXME -- these are not set correctly */
1429 && ((bfd_get_file_flags (current
) & HAS_SYMS
))
1436 if (!bfd_construct_extended_name_table (arch
, &etable
, &elength
))
1439 bfd_seek (arch
, (file_ptr
) 0, SEEK_SET
);
1441 bfd_write (BFD_GNU960_ARMAG (arch
), 1, SARMAG
, arch
);
1443 bfd_write (ARMAG
, 1, SARMAG
, arch
);
1446 if (makemap
&& hasobjects
)
1448 if (compute_and_write_armap (arch
, elength
) != true)
1456 memset ((char *) (&hdr
), 0, sizeof (struct ar_hdr
));
1457 sprintf (&(hdr
.ar_name
[0]), "ARFILENAMES/");
1458 sprintf (&(hdr
.ar_size
[0]), "%-10d", (int) elength
);
1459 hdr
.ar_fmag
[0] = '`';
1460 hdr
.ar_fmag
[1] = '\n';
1461 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
1462 if (((char *) (&hdr
))[i
] == '\0')
1463 (((char *) (&hdr
))[i
]) = ' ';
1464 bfd_write ((char *) &hdr
, 1, sizeof (struct ar_hdr
), arch
);
1465 bfd_write (etable
, 1, elength
, arch
);
1466 if ((elength
% 2) == 1)
1467 bfd_write ("\n", 1, 1, arch
);
1470 for (current
= arch
->archive_head
; current
; current
= current
->next
)
1472 char buffer
[DEFAULT_BUFFERSIZE
];
1473 unsigned int remaining
= arelt_size (current
);
1474 struct ar_hdr
*hdr
= arch_hdr (current
);
1476 /* write ar header */
1477 if (bfd_write ((char *) hdr
, 1, sizeof (*hdr
), arch
) != sizeof (*hdr
))
1480 bfd_error
= system_call_error
;
1483 if (bfd_seek (current
, (file_ptr
) 0, SEEK_SET
) != 0)
1487 unsigned int amt
= DEFAULT_BUFFERSIZE
;
1488 if (amt
> remaining
)
1491 if (bfd_read (buffer
, amt
, 1, current
) != amt
)
1495 /* Looks like a truncated archive. */
1496 bfd_error
= malformed_archive
;
1499 if (bfd_write (buffer
, amt
, 1, arch
) != amt
)
1503 if ((arelt_size (current
) % 2) == 1)
1504 bfd_write ("\n", 1, 1, arch
);
1507 /* Verify the timestamp in the archive file. If it would not be
1508 accepted by the linker, rewrite it until it would be. If
1509 anything odd happens, break out and just return. (The Berkeley
1510 linker checks the timestamp and refuses to read the
1511 table-of-contents if it is >60 seconds less than the file's
1512 modified-time. That painful hack requires this painful hack. */
1517 /* FIXME! This kludge is to avoid adding a member to the xvec,
1518 while generating a small patch for Adobe. FIXME! The
1519 update_armap_timestamp function call should be in the xvec,
1522 if (bfd_update_armap_timestamp (arch) == true) break;
1525 Instead, we check whether in a BSD archive, and call
1528 if (arch
->xvec
->write_armap
!= bsd_write_armap
)
1530 if (bsd_update_armap_timestamp (arch
) == true) /* FIXME!!! Vector it */
1534 "Warning: writing archive was slow: rewriting timestamp\n");
1536 while (++tries
< 6);
1541 /* Note that the namidx for the first symbol is 0 */
1544 compute_and_write_armap (arch
, elength
)
1546 unsigned int elength
;
1549 file_ptr elt_no
= 0;
1551 int orl_max
= 15000; /* fine initial default */
1553 int stridx
= 0; /* string index */
1555 /* Dunno if this is the best place for this info... */
1557 elength
+= sizeof (struct ar_hdr
);
1558 elength
+= elength
% 2;
1560 map
= (struct orl
*) bfd_zalloc (arch
, orl_max
* sizeof (struct orl
));
1563 bfd_error
= no_memory
;
1567 /* Drop all the files called __.SYMDEF, we're going to make our
1569 while (arch
->archive_head
&&
1570 strcmp (arch
->archive_head
->filename
, "__.SYMDEF") == 0)
1571 arch
->archive_head
= arch
->archive_head
->next
;
1573 /* Map over each element */
1574 for (current
= arch
->archive_head
;
1575 current
!= (bfd
*) NULL
;
1576 current
= current
->next
, elt_no
++)
1578 if ((bfd_check_format (current
, bfd_object
) == true)
1579 && ((bfd_get_file_flags (current
) & HAS_SYMS
)))
1582 unsigned int storage
;
1583 unsigned int symcount
;
1584 unsigned int src_count
;
1586 storage
= get_symtab_upper_bound (current
);
1589 syms
= (asymbol
**) bfd_zalloc (arch
, storage
);
1592 bfd_error
= no_memory
; /* FIXME -- memory leak */
1595 symcount
= bfd_canonicalize_symtab (current
, syms
);
1598 /* Now map over all the symbols, picking out the ones we want */
1599 for (src_count
= 0; src_count
< symcount
; src_count
++)
1602 (syms
[src_count
])->flags
;
1604 syms
[src_count
]->section
;
1606 if ((flags
& BSF_GLOBAL
||
1608 flags
& BSF_INDIRECT
||
1609 bfd_is_com_section (sec
))
1610 && (sec
!= &bfd_und_section
))
1612 /* This symbol will go into the archive header */
1613 if (orl_count
== orl_max
)
1616 map
= ((struct orl
*)
1617 bfd_realloc (arch
, (char *) map
,
1618 orl_max
* sizeof (struct orl
)));
1621 (map
[orl_count
]).name
=
1622 (char **) &((syms
[src_count
])->name
);
1623 (map
[orl_count
]).pos
= (file_ptr
) current
;
1624 (map
[orl_count
]).namidx
= stridx
;
1626 stridx
+= strlen ((syms
[src_count
])->name
) + 1;
1634 /* OK, now we have collected all the data, let's write them out */
1635 if (!BFD_SEND (arch
, write_armap
,
1636 (arch
, elength
, map
, orl_count
, stridx
)))
1643 bsd_write_armap (arch
, elength
, map
, orl_count
, stridx
)
1645 unsigned int elength
;
1647 unsigned int orl_count
;
1650 int padit
= stridx
& 1;
1651 unsigned int ranlibsize
= orl_count
* sizeof (struct ranlib
);
1652 unsigned int stringsize
= stridx
+ padit
;
1653 /* Include 8 bytes to store ranlibsize and stringsize in output. */
1654 unsigned int mapsize
= ranlibsize
+ stringsize
+ 8;
1656 bfd
*current
= arch
->archive_head
;
1657 bfd
*last_elt
= current
; /* last element arch seen */
1661 struct stat statbuf
;
1664 firstreal
= mapsize
+ elength
+ sizeof (struct ar_hdr
) + SARMAG
;
1666 stat (arch
->filename
, &statbuf
);
1667 memset ((char *) (&hdr
), 0, sizeof (struct ar_hdr
));
1668 sprintf (hdr
.ar_name
, RANLIBMAG
);
1669 /* Remember the timestamp, to keep it holy. But fudge it a little. */
1670 bfd_ardata (arch
)->armap_timestamp
= statbuf
.st_mtime
+ ARMAP_TIME_OFFSET
;
1671 bfd_ardata (arch
)->armap_datepos
= (SARMAG
1672 + offsetof (struct ar_hdr
, ar_date
[0]));
1673 sprintf (hdr
.ar_date
, "%ld", bfd_ardata (arch
)->armap_timestamp
);
1674 sprintf (hdr
.ar_uid
, "%d", getuid ());
1675 sprintf (hdr
.ar_gid
, "%d", getgid ());
1676 sprintf (hdr
.ar_size
, "%-10d", (int) mapsize
);
1677 hdr
.ar_fmag
[0] = '`';
1678 hdr
.ar_fmag
[1] = '\n';
1679 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
1680 if (((char *) (&hdr
))[i
] == '\0')
1681 (((char *) (&hdr
))[i
]) = ' ';
1682 bfd_write ((char *) &hdr
, 1, sizeof (struct ar_hdr
), arch
);
1683 bfd_h_put_32 (arch
, (bfd_vma
) ranlibsize
, (PTR
) & temp
);
1684 bfd_write (&temp
, 1, sizeof (temp
), arch
);
1686 for (count
= 0; count
< orl_count
; count
++)
1689 struct symdef
*outp
= &outs
;
1691 if (((bfd
*) (map
[count
]).pos
) != last_elt
)
1695 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
1696 firstreal
+= firstreal
% 2;
1697 current
= current
->next
;
1699 while (current
!= (bfd
*) (map
[count
]).pos
);
1700 } /* if new archive element */
1703 bfd_h_put_32 (arch
, ((map
[count
]).namidx
), (PTR
) & outs
.s
.string_offset
);
1704 bfd_h_put_32 (arch
, firstreal
, (PTR
) & outs
.file_offset
);
1705 bfd_write ((char *) outp
, 1, sizeof (outs
), arch
);
1708 /* now write the strings themselves */
1709 bfd_h_put_32 (arch
, stringsize
, (PTR
) & temp
);
1710 bfd_write ((PTR
) & temp
, 1, sizeof (temp
), arch
);
1711 for (count
= 0; count
< orl_count
; count
++)
1712 bfd_write (*((map
[count
]).name
), 1, strlen (*((map
[count
]).name
)) + 1, arch
);
1714 /* The spec sez this should be a newline. But in order to be
1715 bug-compatible for sun's ar we use a null. */
1717 bfd_write ("", 1, 1, arch
);
1722 /* At the end of archive file handling, update the timestamp in the
1723 file, so the linker will accept it.
1725 Return true if the timestamp was OK, or an unusual problem happened.
1726 Return false if we updated the timestamp. */
1729 bsd_update_armap_timestamp (arch
)
1732 struct stat archstat
;
1736 /* Flush writes, get last-write timestamp from file, and compare it
1737 to the timestamp IN the file. */
1739 if (bfd_stat (arch
, &archstat
) == -1)
1741 perror ("Reading archive file mod timestamp");
1742 return true; /* Can't read mod time for some reason */
1744 if (archstat
.st_mtime
<= bfd_ardata (arch
)->armap_timestamp
)
1745 return true; /* OK by the linker's rules */
1747 /* Update the timestamp. */
1748 bfd_ardata (arch
)->armap_timestamp
= archstat
.st_mtime
+ ARMAP_TIME_OFFSET
;
1750 /* Prepare an ASCII version suitable for writing. */
1751 memset (hdr
.ar_date
, 0, sizeof (hdr
.ar_date
));
1752 sprintf (hdr
.ar_date
, "%ld", bfd_ardata (arch
)->armap_timestamp
);
1753 for (i
= 0; i
< sizeof (hdr
.ar_date
); i
++)
1754 if (hdr
.ar_date
[i
] == '\0')
1755 (hdr
.ar_date
)[i
] = ' ';
1757 /* Write it into the file. */
1758 bfd_seek (arch
, bfd_ardata (arch
)->armap_datepos
, SEEK_SET
);
1759 if (bfd_write (hdr
.ar_date
, sizeof (hdr
.ar_date
), 1, arch
)
1760 != sizeof (hdr
.ar_date
))
1762 perror ("Writing updated armap timestamp");
1763 return true; /* Some error while writing */
1766 return false; /* We updated the timestamp successfully. */
1769 /* A coff armap looks like :
1771 struct ar_hdr with name = '/'
1773 offset of file for symbol 0
1774 offset of file for symbol 1
1776 offset of file for symbol n-1
1784 coff_write_armap (arch
, elength
, map
, symbol_count
, stridx
)
1786 unsigned int elength
;
1788 unsigned int symbol_count
;
1791 /* The size of the ranlib is the number of exported symbols in the
1792 archive * the number of bytes in a int, + an int for the count */
1793 unsigned int ranlibsize
= (symbol_count
* 4) + 4;
1794 unsigned int stringsize
= stridx
;
1795 unsigned int mapsize
= stringsize
+ ranlibsize
;
1796 file_ptr archive_member_file_ptr
;
1797 bfd
*current
= arch
->archive_head
;
1801 int padit
= mapsize
& 1;
1806 /* work out where the first object file will go in the archive */
1807 archive_member_file_ptr
= (mapsize
1809 + sizeof (struct ar_hdr
)
1812 memset ((char *) (&hdr
), 0, sizeof (struct ar_hdr
));
1813 hdr
.ar_name
[0] = '/';
1814 sprintf (hdr
.ar_size
, "%-10d", (int) mapsize
);
1815 sprintf (hdr
.ar_date
, "%ld", (long) time (NULL
));
1816 /* This, at least, is what Intel coff sets the values to.: */
1817 sprintf ((hdr
.ar_uid
), "%d", 0);
1818 sprintf ((hdr
.ar_gid
), "%d", 0);
1819 sprintf ((hdr
.ar_mode
), "%-7o", (unsigned) 0);
1820 hdr
.ar_fmag
[0] = '`';
1821 hdr
.ar_fmag
[1] = '\n';
1823 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
1824 if (((char *) (&hdr
))[i
] == '\0')
1825 (((char *) (&hdr
))[i
]) = ' ';
1827 /* Write the ar header for this item and the number of symbols */
1829 bfd_write ((PTR
) & hdr
, 1, sizeof (struct ar_hdr
), arch
);
1831 bfd_write_bigendian_4byte_int (arch
, symbol_count
);
1833 /* Two passes, first write the file offsets for each symbol -
1834 remembering that each offset is on a two byte boundary. */
1836 /* Write out the file offset for the file associated with each
1837 symbol, and remember to keep the offsets padded out. */
1839 current
= arch
->archive_head
;
1841 while (current
!= (bfd
*) NULL
&& count
< symbol_count
)
1843 /* For each symbol which is used defined in this object, write out
1844 the object file's address in the archive */
1846 while (((bfd
*) (map
[count
]).pos
) == current
)
1848 bfd_write_bigendian_4byte_int (arch
, archive_member_file_ptr
);
1851 /* Add size of this archive entry */
1852 archive_member_file_ptr
+= arelt_size (current
) + sizeof (struct
1854 /* remember aboout the even alignment */
1855 archive_member_file_ptr
+= archive_member_file_ptr
% 2;
1856 current
= current
->next
;
1859 /* now write the strings themselves */
1860 for (count
= 0; count
< symbol_count
; count
++)
1861 bfd_write ((PTR
) * ((map
[count
]).name
),
1863 strlen (*((map
[count
]).name
)) + 1, arch
);
1865 /* The spec sez this should be a newline. But in order to be
1866 bug-compatible for arc960 we use a null. */
1868 bfd_write ("", 1, 1, arch
);