1 /* BFD back-end for archive files (libraries).
2 Copyright (C) 1990-1991 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
25 Gumby, you promised to write this bit...
27 Archives are supported in BFD in @code{archive.c}.
29 An archive is represented internally just like another BFD, with a
30 pointer to a chain of contained BFDs. Archives can be created by
31 opening BFDs, linking them together and attaching them as children to
32 another BFD and then closing the parent BFD.
37 o - all archive elements start on an even boundary, newline padded;
38 o - all arch headers are char *;
39 o - all arch headers are the same size (across architectures).
51 #define BFD_GNU960_ARMAG(abfd) (BFD_COFF_FILE_P((abfd)) ? ARMAG : ARMAGB)
54 /* We keep a cache of archive filepointers to archive elements to
55 speed up searching the archive by filepos. We only add an entry to
56 the cache when we actually read one. We also don't sort the cache;
57 it's short enough to search linearly.
58 Note that the pointers here point to the front of the ar_hdr, not
59 to the front of the contents!
64 struct ar_cache
*next
;
67 #define ar_padchar(abfd) ((abfd)->xvec->ar_pad_char)
68 #define ar_maxnamelen(abfd) ((abfd)->xvec->ar_max_namelen)
70 #define arch_hdr(bfd) ((struct ar_hdr *) \
71 (((struct areltdata *)((bfd)->arelt_data))->arch_header))
74 _bfd_generic_mkarchive (abfd
)
77 set_tdata (abfd
, bfd_zalloc(abfd
, sizeof (struct artdata
)));
79 if (bfd_ardata (abfd
) == NULL
) {
80 bfd_error
= no_memory
;
83 bfd_ardata(abfd
)->cache
= 0;
87 /*proto* bfd_get_next_mapent
89 *; PROTO(symindex, bfd_get_next_mapent, (bfd *, symindex, carsym **));
92 bfd_get_next_mapent (abfd
, prev
, entry
)
97 if (!bfd_has_map (abfd
)) {
98 bfd_error
= invalid_operation
;
99 return BFD_NO_MORE_SYMBOLS
;
102 if (prev
== BFD_NO_MORE_SYMBOLS
) prev
= 0;
103 else if (++prev
>= bfd_ardata (abfd
)->symdef_count
)
104 return BFD_NO_MORE_SYMBOLS
;
106 *entry
= (bfd_ardata (abfd
)->symdefs
+ prev
);
111 /* To be called by backends only */
113 _bfd_create_empty_archive_element_shell (obfd
)
118 nbfd
= new_bfd_contained_in(obfd
);
120 bfd_error
= no_memory
;
126 /*proto* bfd_set_archive_head
128 Used whilst processing archives. Sets the head of the chain of BFDs
129 contained in an archive to @var{new_head}. (see chapter on archives)
131 *; PROTO(boolean, bfd_set_archive_head, (bfd *output, bfd *new_head));
136 DEFUN(bfd_set_archive_head
,(output_archive
, new_head
),
137 bfd
*output_archive AND
141 output_archive
->archive_head
= new_head
;
146 look_for_bfd_in_cache (arch_bfd
, filepos
)
150 struct ar_cache
*current
;
152 for (current
= bfd_ardata (arch_bfd
)->cache
; current
!= NULL
;
153 current
= current
->next
)
154 if (current
->ptr
== filepos
) return current
->arelt
;
159 /* Kind of stupid to call cons for each one, but we don't do too many */
161 add_bfd_to_cache (arch_bfd
, filepos
, new_elt
)
162 bfd
*arch_bfd
, *new_elt
;
165 struct ar_cache
*new_cache
= (struct ar_cache
*)
166 bfd_zalloc(arch_bfd
, sizeof (struct ar_cache
));
168 if (new_cache
== NULL
) {
169 bfd_error
= no_memory
;
173 new_cache
->ptr
= filepos
;
174 new_cache
->arelt
= new_elt
;
175 new_cache
->next
= (struct ar_cache
*)NULL
;
176 if (bfd_ardata (arch_bfd
)->cache
== NULL
)
177 bfd_ardata (arch_bfd
)->cache
= new_cache
;
179 struct ar_cache
*current
= bfd_ardata (arch_bfd
)->cache
;
181 for (; current
->next
!= NULL
; current
= current
->next
);
182 current
->next
= new_cache
;
190 /* The name begins with space. Hence the rest of the name is an index into
194 get_extended_arelt_filename (arch
, name
)
201 unsigned long index
= 0;
203 /* Should extract string so that I can guarantee not to overflow into
204 the next region, but I"m too lazy. */
206 index
= strtol (name
, NULL
, 10);
208 bfd_error
= malformed_archive
;
212 return bfd_ardata (arch
)->extended_names
+ index
;
215 /* This functions reads an arch header and returns an areltdata pointer, or
218 Presumes the file pointer is already in the right place (ie pointing
219 to the ar_hdr in the file). Moves the file pointer; on success it
220 should be pointing to the front of the file contents; on failure it
221 could have been moved arbitrarily.
233 char *hdrp
= (char *) &hdr
;
234 unsigned int parsed_size
;
235 struct areltdata
*ared
;
236 char *filename
= NULL
;
237 unsigned int namelen
= 0;
238 unsigned int allocsize
= sizeof (struct areltdata
) + sizeof (struct ar_hdr
);
241 if (bfd_read ((PTR
)hdrp
, 1, sizeof (struct ar_hdr
), abfd
)
242 != sizeof (struct ar_hdr
)) {
243 bfd_error
= no_more_archived_files
;
246 if (strncmp ((hdr
.ar_fmag
), ARFMAG
, 2)) {
247 bfd_error
= malformed_archive
;
252 parsed_size
= strtol (hdr
.ar_size
, NULL
, 10);
254 bfd_error
= malformed_archive
;
258 /* extract the filename from the archive - there are two ways to
259 specify an extendend name table, either the first char of the
260 name is a space, or it's a slash */
261 if ((hdr
.ar_name
[0] == '/' || hdr
.ar_name
[0] == ' ') && bfd_ardata (abfd
)->extended_names
!= NULL
) {
262 filename
= get_extended_arelt_filename (abfd
, hdr
.ar_name
);
263 if (filename
== NULL
) {
264 bfd_error
= malformed_archive
;
270 /* We judge the end of the name by looking for a space or a
275 while (namelen
< (unsigned)ar_maxnamelen(abfd
) &&
276 ( hdr
.ar_name
[namelen
] != 0 &&
277 hdr
.ar_name
[namelen
] != ' ' &&
278 hdr
.ar_name
[namelen
] != ar_padchar(abfd
))) {
282 allocsize
+= namelen
+ 1;
285 allocptr
= bfd_zalloc(abfd
, allocsize
);
286 if (allocptr
== NULL
) {
287 bfd_error
= no_memory
;
291 ared
= (struct areltdata
*) allocptr
;
293 ared
->arch_header
= allocptr
+ sizeof (struct areltdata
);
294 memcpy ((char *) ared
->arch_header
, (char *) &hdr
, sizeof (struct ar_hdr
));
295 ared
->parsed_size
= parsed_size
;
297 if (filename
!= NULL
) ared
->filename
= filename
;
299 ared
->filename
= allocptr
+ (sizeof (struct areltdata
) +
300 sizeof (struct ar_hdr
));
302 memcpy (ared
->filename
, hdr
.ar_name
, namelen
);
303 ared
->filename
[namelen
] = '\0';
310 get_elt_at_filepos (archive
, filepos
)
314 struct areltdata
*new_areldata
;
317 n_nfd
= look_for_bfd_in_cache (archive
, filepos
);
318 if (n_nfd
) return n_nfd
;
320 if (0 > bfd_seek (archive
, filepos
, SEEK_SET
)) {
321 bfd_error
= system_call_error
;
325 if ((new_areldata
= snarf_ar_hdr (archive
)) == NULL
) return NULL
;
327 n_nfd
= _bfd_create_empty_archive_element_shell (archive
);
329 bfd_release (archive
, (PTR
)new_areldata
);
332 n_nfd
->origin
= bfd_tell (archive
);
333 n_nfd
->arelt_data
= (PTR
) new_areldata
;
334 n_nfd
->filename
= new_areldata
->filename
;
336 if (add_bfd_to_cache (archive
, filepos
, n_nfd
))
340 bfd_release (archive
, (PTR
)n_nfd
);
341 bfd_release (archive
, (PTR
)new_areldata
);
345 /*proto* bfd_get_elt_at_index
346 Return the sub bfd contained within the archive at archive index n.
348 *; PROTO(bfd *, bfd_get_elt_at_index, (bfd *, int));
352 bfd_get_elt_at_index (abfd
, index
)
358 (abfd
, (bfd_ardata (abfd
)->symdefs
+ index
)->file_offset
);
362 /*proto* bfd_openr_next_archived_file
363 Initially provided a BFD containing an archive and NULL, opens a BFD
364 on the first contained element and returns that. Subsequent calls to
365 bfd_openr_next_archived_file should pass the archive and the previous
366 return value to return a created BFD to the next contained element.
367 NULL is returned when there are no more.
369 *; PROTO(bfd*, bfd_openr_next_archived_file,
370 (bfd *archive, bfd *previous));
375 DEFUN(bfd_openr_next_archived_file
,(archive
, last_file
),
380 if ((bfd_get_format (archive
) != bfd_archive
) ||
381 (archive
->direction
== write_direction
)) {
382 bfd_error
= invalid_operation
;
387 return BFD_SEND (archive
,
388 openr_next_archived_file
,
394 bfd
*bfd_generic_openr_next_archived_file(archive
, last_file
)
401 filestart
= bfd_ardata (archive
)->first_file_filepos
;
403 unsigned int size
= arelt_size(last_file
);
404 /* Pad to an even boundary... */
405 filestart
= last_file
->origin
+ size
+ size
%2;
408 return get_elt_at_filepos (archive
, filestart
);
413 bfd_generic_archive_p (abfd
)
416 char armag
[SARMAG
+1];
418 if (bfd_read ((PTR
)armag
, 1, SARMAG
, abfd
) != SARMAG
) {
419 bfd_error
= wrong_format
;
424 if (strncmp (armag
, BFD_GNU960_ARMAG(abfd
), SARMAG
)) return 0;
426 if (strncmp (armag
, ARMAG
, SARMAG
)) return 0;
429 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
430 involves a cast, we can't do it as the left operand of assignment. */
431 set_tdata (abfd
, bfd_zalloc(abfd
,sizeof (struct artdata
)));
433 if (bfd_ardata (abfd
) == NULL
) {
434 bfd_error
= no_memory
;
438 bfd_ardata (abfd
)->first_file_filepos
= SARMAG
;
440 if (!BFD_SEND (abfd
, _bfd_slurp_armap
, (abfd
))) {
441 bfd_release(abfd
, bfd_ardata (abfd
));
446 if (!BFD_SEND (abfd
, _bfd_slurp_extended_name_table
, (abfd
))) {
447 bfd_release(abfd
, bfd_ardata (abfd
));
455 /* Returns false on error, true otherwise */
457 bfd_slurp_bsd_armap (abfd
)
461 struct areltdata
*mapdata
;
463 unsigned int counter
= 0;
464 int *raw_armap
, *rbase
;
465 struct artdata
*ardata
= bfd_ardata (abfd
);
468 /* FIXME, if the read fails, this routine quietly returns "true"!!
469 It should probably do that if the read gives 0 bytes (empty archive),
470 but fail for any other size... */
471 if (bfd_read ((PTR
)nextname
, 1, 16, abfd
) == 16) {
472 /* The archive has at least 16 bytes in it */
473 bfd_seek (abfd
, -16L, SEEK_CUR
);
475 /* This should be using RANLIBMAG, but at least it can be grepped for
477 if (strncmp (nextname
, "__.SYMDEF ", 16)) {
478 bfd_has_map (abfd
) = false;
482 mapdata
= snarf_ar_hdr (abfd
);
483 if (mapdata
== NULL
) return false;
485 raw_armap
= (int *) bfd_zalloc(abfd
,mapdata
->parsed_size
);
486 if (raw_armap
== NULL
) {
487 bfd_error
= no_memory
;
489 bfd_release (abfd
, (PTR
)mapdata
);
493 if (bfd_read ((PTR
)raw_armap
, 1, mapdata
->parsed_size
, abfd
) !=
494 mapdata
->parsed_size
) {
495 bfd_error
= malformed_archive
;
496 bfd_release (abfd
, (PTR
)raw_armap
);
500 ardata
->symdef_count
= bfd_h_get_32(abfd
, (PTR
)raw_armap
) / sizeof (struct symdef
);
503 ardata
->symdefs
= (carsym
*) rbase
;
504 stringbase
= ((char *) (ardata
->symdefs
+ ardata
->symdef_count
)) + 4;
506 for (;counter
< ardata
->symdef_count
; counter
++) {
507 struct symdef
*sym
= ((struct symdef
*) rbase
) + counter
;
508 sym
->s
.name
= bfd_h_get_32(abfd
, (PTR
)(&(sym
->s
.string_offset
))) + stringbase
;
509 sym
->file_offset
= bfd_h_get_32(abfd
, (PTR
)( &(sym
->file_offset
)));
512 ardata
->first_file_filepos
= bfd_tell (abfd
);
513 /* Pad to an even boundary if you have to */
514 ardata
->first_file_filepos
+= (ardata
-> first_file_filepos
) %2;
515 /* FIXME, we should provide some way to free raw_ardata when
516 we are done using the strings from it. For now, it seems
517 to be allocated on an obstack anyway... */
518 bfd_has_map (abfd
) = true;
523 /* Returns false on error, true otherwise */
525 bfd_slurp_coff_armap (abfd
)
528 struct areltdata
*mapdata
;
530 int *raw_armap
, *rawptr
;
531 struct artdata
*ardata
= bfd_ardata (abfd
);
533 unsigned int stringsize
;
537 result
= bfd_read ((PTR
)&nextname
, 1, 1, abfd
);
538 bfd_seek (abfd
, -1L, SEEK_CUR
);
540 if (result
!= 1 || nextname
!= '/') {
541 /* Actually I think this is an error for a COFF archive */
542 bfd_has_map (abfd
) = false;
546 mapdata
= snarf_ar_hdr (abfd
);
547 if (mapdata
== NULL
) return false;
549 raw_armap
= (int *) bfd_alloc(abfd
,mapdata
->parsed_size
);
551 if (raw_armap
== NULL
)
553 bfd_error
= no_memory
;
555 bfd_release (abfd
, (PTR
)mapdata
);
559 /* read in the raw map */
560 if (bfd_read ((PTR
)raw_armap
, 1, mapdata
->parsed_size
, abfd
) !=
561 mapdata
->parsed_size
) {
562 bfd_error
= malformed_archive
;
564 bfd_release (abfd
, (PTR
)raw_armap
);
568 /* The coff armap must be read sequentially. So we construct a bsd-style
569 one in core all at once, for simplicity.
571 It seems that all numeric information in a coff archive is always
572 in big endian format, nomatter the host or target. */
574 stringsize
= mapdata
->parsed_size
- (4 * (_do_getb32((PTR
)raw_armap
))) - 4;
577 unsigned int nsymz
= _do_getb32( (PTR
)raw_armap
);
578 unsigned int carsym_size
= (nsymz
* sizeof (carsym
));
579 unsigned int ptrsize
= (4 * nsymz
);
581 ardata
->symdefs
= (carsym
*) bfd_zalloc(abfd
,carsym_size
+ stringsize
+ 1);
582 if (ardata
->symdefs
== NULL
) {
583 bfd_error
= no_memory
;
586 carsyms
= ardata
->symdefs
;
588 stringbase
= ((char *) ardata
->symdefs
) + carsym_size
;
589 memcpy (stringbase
, (char*)raw_armap
+ ptrsize
+ 4, stringsize
);
592 /* OK, build the carsyms */
593 for (i
= 0; i
< nsymz
; i
++)
595 rawptr
= raw_armap
+ i
+ 1;
596 carsyms
->file_offset
= _do_getb32((PTR
)rawptr
);
597 carsyms
->name
= stringbase
;
598 for (; *(stringbase
++););
603 ardata
->symdef_count
= _do_getb32((PTR
)raw_armap
);
604 ardata
->first_file_filepos
= bfd_tell (abfd
);
605 /* Pad to an even boundary if you have to */
606 ardata
->first_file_filepos
+= (ardata
->first_file_filepos
) %2;
608 /* We'd like to release these allocations, but we have allocated stuff
609 since then (using the same obstack, if bfd_release is obstack based).
610 So they will stick around until the BFD is closed. */
611 /* bfd_release (abfd, (PTR)raw_armap);
612 bfd_release (abfd, (PTR)mapdata); */
613 bfd_has_map (abfd
) = true;
617 /** Extended name table.
619 Normally archives support only 14-character filenames.
621 Intel has extended the format: longer names are stored in a special
622 element (the first in the archive, or second if there is an armap);
623 the name in the ar_hdr is replaced by <space><index into filename
624 element>. Index is the P.R. of an int (radix: 8). Data General have
625 extended the format by using the prefix // for the special element */
627 /* Returns false on error, true otherwise */
629 _bfd_slurp_extended_name_table (abfd
)
633 struct areltdata
*namedata
;
635 /* FIXME: Formatting sucks here, and in case of failure of BFD_READ,
636 we probably don't want to return true. */
637 if (bfd_read ((PTR
)nextname
, 1, 16, abfd
) == 16) {
639 bfd_seek (abfd
, -16L, SEEK_CUR
);
641 if (strncmp (nextname
, "ARFILENAMES/ ", 16) != 0 &&
642 strncmp (nextname
, "// ", 16) != 0)
644 bfd_ardata (abfd
)->extended_names
= NULL
;
648 namedata
= snarf_ar_hdr (abfd
);
649 if (namedata
== NULL
) return false;
651 bfd_ardata (abfd
)->extended_names
= bfd_zalloc(abfd
,namedata
->parsed_size
);
652 if (bfd_ardata (abfd
)->extended_names
== NULL
) {
653 bfd_error
= no_memory
;
655 bfd_release (abfd
, (PTR
)namedata
);
659 if (bfd_read ((PTR
)bfd_ardata (abfd
)->extended_names
, 1,
660 namedata
->parsed_size
, abfd
) != namedata
->parsed_size
) {
661 bfd_error
= malformed_archive
;
662 bfd_release (abfd
, (PTR
)(bfd_ardata (abfd
)->extended_names
));
663 bfd_ardata (abfd
)->extended_names
= NULL
;
667 /* Since the archive is supposed to be printable if it contains
668 text, the entries in the list are newline-padded, not null
669 padded. We'll fix that there.. */
671 char *temp
= bfd_ardata (abfd
)->extended_names
;
672 for (; *temp
!= '\0'; ++temp
)
673 if (*temp
== '\n') *temp
= '\0';
676 /* Pad to an even boundary if you have to */
677 bfd_ardata (abfd
)->first_file_filepos
= bfd_tell (abfd
);
678 bfd_ardata (abfd
)->first_file_filepos
+=
679 (bfd_ardata (abfd
)->first_file_filepos
) %2;
681 /* FIXME, we can't release namedata here because it was allocated
682 below extended_names on the obstack... */
683 /* bfd_release (abfd, namedata); */
689 char *normalize(file
)
692 char * filename
= strrchr(file
, '/');
693 if (filename
!= (char *)NULL
) {
702 /* Follows archive_head and produces an extended name table if necessary.
703 Returns (in tabloc) a pointer to an extended name table, and in tablen
704 the length of the table. If it makes an entry it clobbers the filename
705 so that the element may be written without further massage.
706 Returns true if it ran successfully, false if something went wrong.
707 A successful return may still involve a zero-length tablen!
710 bfd_construct_extended_name_table (abfd
, tabloc
, tablen
)
713 unsigned int *tablen
;
715 unsigned int maxname
= abfd
->xvec
->ar_max_namelen
;
716 unsigned int total_namelen
= 0;
722 /* Figure out how long the table should be */
723 for (current
= abfd
->archive_head
; current
!= NULL
; current
= current
->next
){
724 unsigned int thislen
= strlen (normalize(current
->filename
));
725 if (thislen
> maxname
) total_namelen
+= thislen
+ 1; /* leave room for \n */
728 if (total_namelen
== 0) return true;
730 *tabloc
= bfd_zalloc (abfd
,total_namelen
);
731 if (*tabloc
== NULL
) {
732 bfd_error
= no_memory
;
736 *tablen
= total_namelen
;
739 for (current
= abfd
->archive_head
; current
!= NULL
; current
=
741 char *normal
=normalize( current
->filename
);
742 unsigned int thislen
= strlen (normal
);
743 if (thislen
> maxname
) {
744 /* Works for now; may need to be re-engineered if we encounter an oddball
745 archive format and want to generalise this hack. */
746 struct ar_hdr
*hdr
= arch_hdr(current
);
747 strcpy (strptr
, normal
);
748 strptr
[thislen
] = '\n';
749 hdr
->ar_name
[0] = ' ';
750 /* We know there will always be enough room (one of the few cases
751 where you may safely use sprintf). */
752 sprintf ((hdr
->ar_name
) + 1, "%-o", (unsigned) (strptr
- *tabloc
));
753 /* Kinda Kludgy. We should just use the returned value of sprintf
754 but not all implementations get this right */
756 char *temp
= hdr
->ar_name
+2;
757 for (; temp
< hdr
->ar_name
+ maxname
; temp
++)
758 if (*temp
== '\0') *temp
= ' ';
760 strptr
+= thislen
+ 1;
767 /** A couple of functions for creating ar_hdrs */
769 /* Takes a filename, returns an arelt_data for it, or NULL if it can't make one.
770 The filename must refer to a filename in the filesystem.
771 The filename field of the ar_hdr will NOT be initialized
775 DEFUN(bfd_ar_hdr_from_filesystem
, (abfd
,filename
),
777 CONST
char *filename
)
780 struct areltdata
*ared
;
785 if (stat (filename
, &status
) != 0) {
786 bfd_error
= system_call_error
;
790 ared
= (struct areltdata
*) bfd_zalloc(abfd
, sizeof (struct ar_hdr
) +
791 sizeof (struct areltdata
));
793 bfd_error
= no_memory
;
796 hdr
= (struct ar_hdr
*) (((char *) ared
) + sizeof (struct areltdata
));
798 /* ar headers are space padded, not null padded! */
800 temp1
= temp
+ sizeof (struct ar_hdr
) - 2;
801 for (; temp
< temp1
; *(temp
++) = ' ');
802 strncpy (hdr
->ar_fmag
, ARFMAG
, 2);
804 /* Goddamned sprintf doesn't permit MAXIMUM field lengths */
805 sprintf ((hdr
->ar_date
), "%-12ld", status
.st_mtime
);
806 sprintf ((hdr
->ar_uid
), "%d", status
.st_uid
);
807 sprintf ((hdr
->ar_gid
), "%d", status
.st_gid
);
808 sprintf ((hdr
->ar_mode
), "%-8o", (unsigned) status
.st_mode
);
809 sprintf ((hdr
->ar_size
), "%-10ld", status
.st_size
);
810 /* Correct for a lossage in sprintf whereby it null-terminates. I cannot
811 understand how these C losers could design such a ramshackle bunch of
814 temp1
= temp
+ sizeof (struct ar_hdr
) - 2;
815 for (; temp
< temp1
; temp
++) {
816 if (*temp
== '\0') *temp
= ' ';
818 strncpy (hdr
->ar_fmag
, ARFMAG
, 2);
819 ared
->parsed_size
= status
.st_size
;
820 ared
->arch_header
= (char *) hdr
;
826 DEFUN(bfd_special_undocumented_glue
, (abfd
, filename
),
830 struct areltdata
*ar_elt
= bfd_ar_hdr_from_filesystem (abfd
, filename
);
833 return (struct ar_hdr
*) ar_elt
->arch_header
;
837 /* Analogous to stat call */
839 bfd_generic_stat_arch_elt (abfd
, buf
)
846 if (abfd
->arelt_data
== NULL
) {
847 bfd_error
= invalid_operation
;
851 hdr
= arch_hdr (abfd
);
853 #define foo(arelt, stelt, size) \
854 buf->stelt = strtol (hdr->arelt, &aloser, size); \
855 if (aloser == hdr->arelt) return -1;
857 foo (ar_date
, st_mtime
, 10);
858 foo (ar_uid
, st_uid
, 10);
859 foo (ar_gid
, st_gid
, 10);
860 foo (ar_mode
, st_mode
, 8);
861 foo (ar_size
, st_size
, 10);
867 bfd_dont_truncate_arname (abfd
, pathname
, arhdr
)
869 CONST
char *pathname
;
872 /* FIXME: This interacts unpleasantly with ar's quick-append option.
873 Fortunately ic960 users will never use that option. Fixing this
874 is very hard; fortunately I know how to do it and will do so once
875 intel's release is out the door. */
877 struct ar_hdr
*hdr
= (struct ar_hdr
*) arhdr
;
879 CONST
char *filename
= strrchr (pathname
, '/');
880 int maxlen
= ar_maxnamelen (abfd
);
882 if (filename
== NULL
)
887 length
= strlen (filename
);
889 if (length
<= maxlen
)
890 memcpy (hdr
->ar_name
, filename
, length
);
892 if (length
< maxlen
) (hdr
->ar_name
)[length
] = ar_padchar (abfd
);
898 bfd_bsd_truncate_arname (abfd
, pathname
, arhdr
)
900 CONST
char *pathname
;
903 struct ar_hdr
*hdr
= (struct ar_hdr
*) arhdr
;
905 CONST
char *filename
= strrchr (pathname
, '/');
906 int maxlen
= ar_maxnamelen (abfd
);
909 if (filename
== NULL
)
914 length
= strlen (filename
);
916 if (length
<= maxlen
)
917 memcpy (hdr
->ar_name
, filename
, length
);
919 /* pathname: meet procrustes */
920 memcpy (hdr
->ar_name
, filename
, maxlen
);
924 if (length
< maxlen
) (hdr
->ar_name
)[length
] = ar_padchar (abfd
);
927 /* Store name into ar header. Truncates the name to fit.
928 1> strip pathname to be just the basename.
929 2> if it's short enuf to fit, stuff it in.
930 3> If it doesn't end with .o, truncate it to fit
931 4> truncate it before the .o, append .o, stuff THAT in.
934 /* This is what gnu ar does. It's better but incompatible with the bsd ar. */
936 bfd_gnu_truncate_arname (abfd
, pathname
, arhdr
)
938 CONST
char *pathname
;
941 struct ar_hdr
*hdr
= (struct ar_hdr
*) arhdr
;
943 CONST
char *filename
= strrchr (pathname
, '/');
944 int maxlen
= ar_maxnamelen (abfd
);
946 if (filename
== NULL
)
951 length
= strlen (filename
);
953 if (length
<= maxlen
)
954 memcpy (hdr
->ar_name
, filename
, length
);
955 else { /* pathname: meet procrustes */
956 memcpy (hdr
->ar_name
, filename
, maxlen
);
957 if ((filename
[length
- 2] == '.') && (filename
[length
- 1] == 'o')) {
958 hdr
->ar_name
[maxlen
- 2] = '.';
959 hdr
->ar_name
[maxlen
- 1] = 'o';
964 if (length
< 16) (hdr
->ar_name
)[length
] = ar_padchar (abfd
);
968 PROTO (boolean
, compute_and_write_armap
, (bfd
*arch
, unsigned int elength
));
970 /* The BFD is open for write and has its format set to bfd_archive */
972 _bfd_write_archive_contents (arch
)
977 unsigned int elength
= 0;
978 boolean makemap
= bfd_has_map (arch
);
979 boolean hasobjects
= false; /* if no .o's, don't bother to make a map */
982 /* Verify the viability of all entries; if any of them live in the
983 filesystem (as opposed to living in an archive open for input)
984 then construct a fresh ar_hdr for them.
986 for (current
= arch
->archive_head
; current
; current
= current
->next
) {
987 if (bfd_write_p (current
)) {
988 bfd_error
= invalid_operation
;
991 if (!current
->arelt_data
) {
992 current
->arelt_data
=
993 (PTR
) bfd_ar_hdr_from_filesystem (arch
, current
->filename
);
994 if (!current
->arelt_data
) return false;
996 /* Put in the file name */
998 BFD_SEND (arch
, _bfd_truncate_arname
,(arch
,
1000 (char *) arch_hdr(current
)));
1005 if (makemap
) { /* don't bother if we won't make a map! */
1006 if ((bfd_check_format (current
, bfd_object
))
1007 #if 0 /* FIXME -- these are not set correctly */
1008 && ((bfd_get_file_flags (current
) & HAS_SYMS
))
1015 if (!bfd_construct_extended_name_table (arch
, &etable
, &elength
))
1018 bfd_seek (arch
, 0, SEEK_SET
);
1020 bfd_write (BFD_GNU960_ARMAG(arch
), 1, SARMAG
, arch
);
1022 bfd_write (ARMAG
, 1, SARMAG
, arch
);
1025 if (makemap
&& hasobjects
) {
1027 if (compute_and_write_armap (arch
, elength
) != true) {
1035 memset ((char *)(&hdr
), 0, sizeof (struct ar_hdr
));
1036 sprintf (&(hdr
.ar_name
[0]), "ARFILENAMES/");
1037 sprintf (&(hdr
.ar_size
[0]), "%-10d", (int) elength
);
1038 hdr
.ar_fmag
[0] = '`'; hdr
.ar_fmag
[1] = '\n';
1039 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
1040 if (((char *)(&hdr
))[i
] == '\0') (((char *)(&hdr
))[i
]) = ' ';
1041 bfd_write ((char *)&hdr
, 1, sizeof (struct ar_hdr
), arch
);
1042 bfd_write (etable
, 1, elength
, arch
);
1043 if ((elength
% 2) == 1) bfd_write ("\n", 1, 1, arch
);
1047 for (current
= arch
->archive_head
; current
; current
= current
->next
) {
1048 char buffer
[DEFAULT_BUFFERSIZE
];
1049 unsigned int remaining
= arelt_size (current
);
1050 struct ar_hdr
*hdr
= arch_hdr(current
);
1051 /* write ar header */
1053 if (bfd_write ((char *)hdr
, 1, sizeof(*hdr
), arch
) != sizeof(*hdr
)) {
1055 bfd_error
= system_call_error
;
1058 if (bfd_seek (current
, 0L, SEEK_SET
) != 0L) goto syserr
;
1061 unsigned int amt
= DEFAULT_BUFFERSIZE
;
1062 if (amt
> remaining
) {
1065 if (bfd_read (buffer
, amt
, 1, current
) != amt
) goto syserr
;
1066 if (bfd_write (buffer
, amt
, 1, arch
) != amt
) goto syserr
;
1069 if ((arelt_size (current
) % 2) == 1) bfd_write ("\n", 1, 1, arch
);
1074 /* Note that the namidx for the first symbol is 0 */
1077 compute_and_write_armap (arch
, elength
)
1079 unsigned int elength
;
1082 file_ptr elt_no
= 0;
1084 int orl_max
= 15000; /* fine initial default */
1086 int stridx
= 0; /* string index */
1088 /* Dunno if this is the best place for this info... */
1089 if (elength
!= 0) elength
+= sizeof (struct ar_hdr
);
1090 elength
+= elength
%2 ;
1092 map
= (struct orl
*) bfd_zalloc (arch
,orl_max
* sizeof (struct orl
));
1094 bfd_error
= no_memory
;
1098 /* Drop all the files called __.SYMDEF, we're going to make our
1100 while (arch
->archive_head
&&
1101 strcmp(arch
->archive_head
->filename
,"__.SYMDEF") == 0)
1103 arch
->archive_head
= arch
->archive_head
->next
;
1105 /* Map over each element */
1106 for (current
= arch
->archive_head
;
1107 current
!= (bfd
*)NULL
;
1108 current
= current
->next
, elt_no
++)
1110 if ((bfd_check_format (current
, bfd_object
) == true)
1111 && ((bfd_get_file_flags (current
) & HAS_SYMS
))) {
1113 unsigned int storage
;
1114 unsigned int symcount
;
1115 unsigned int src_count
;
1117 storage
= get_symtab_upper_bound (current
);
1120 syms
= (asymbol
**) bfd_zalloc (arch
,storage
);
1122 bfd_error
= no_memory
; /* FIXME -- memory leak */
1125 symcount
= bfd_canonicalize_symtab (current
, syms
);
1128 /* Now map over all the symbols, picking out the ones we want */
1129 for (src_count
= 0; src_count
<symcount
; src_count
++) {
1130 flagword flags
= (syms
[src_count
])->flags
;
1131 if ((flags
& BSF_GLOBAL
) ||
1132 (flags
& BSF_FORT_COMM
)) {
1134 /* This symbol will go into the archive header */
1135 if (orl_count
== orl_max
)
1138 map
= (struct orl
*) bfd_realloc (arch
, (char *) map
,
1139 orl_max
* sizeof (struct orl
));
1142 (map
[orl_count
]).name
= (char **) &((syms
[src_count
])->name
);
1143 (map
[orl_count
]).pos
= (file_ptr
) current
;
1144 (map
[orl_count
]).namidx
= stridx
;
1146 stridx
+= strlen ((syms
[src_count
])->name
) + 1;
1153 /* OK, now we have collected all the data, let's write them out */
1154 if (!BFD_SEND (arch
, write_armap
,
1155 (arch
, elength
, map
, orl_count
, stridx
))) {
1165 bsd_write_armap (arch
, elength
, map
, orl_count
, stridx
)
1167 unsigned int elength
;
1169 unsigned int orl_count
;
1172 unsigned int ranlibsize
= orl_count
* sizeof (struct ranlib
);
1173 unsigned int stringsize
= stridx
+ 4;
1174 unsigned int mapsize
= stringsize
+ ranlibsize
+ 4;
1176 bfd
*current
= arch
->archive_head
;
1177 bfd
*last_elt
= current
; /* last element arch seen */
1181 struct stat statbuf
;
1183 int padit
= mapsize
& 1;
1185 if (padit
) mapsize
++;
1187 firstreal
= mapsize
+ elength
+ sizeof (struct ar_hdr
) + SARMAG
;
1189 stat (arch
->filename
, &statbuf
);
1190 memset ((char *)(&hdr
), 0, sizeof (struct ar_hdr
));
1191 sprintf (hdr
.ar_name
, RANLIBMAG
);
1192 sprintf (hdr
.ar_date
, "%ld", statbuf
.st_mtime
);
1193 sprintf (hdr
.ar_uid
, "%d", getuid());
1194 sprintf (hdr
.ar_gid
, "%d", getgid());
1195 sprintf (hdr
.ar_size
, "%-10d", (int) mapsize
);
1196 hdr
.ar_fmag
[0] = '`'; hdr
.ar_fmag
[1] = '\n';
1197 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
1198 if (((char *)(&hdr
))[i
] == '\0') (((char *)(&hdr
))[i
]) = ' ';
1199 bfd_write ((char *)&hdr
, 1, sizeof (struct ar_hdr
), arch
);
1200 bfd_h_put_32(arch
, ranlibsize
, (PTR
)&temp
);
1201 bfd_write (&temp
, 1, sizeof (temp
), arch
);
1203 for (count
= 0; count
< orl_count
; count
++) {
1205 struct symdef
*outp
= &outs
;
1207 if (((bfd
*)(map
[count
]).pos
) != last_elt
) {
1209 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
1210 firstreal
+= firstreal
% 2;
1211 current
= current
->next
;
1212 } while (current
!= (bfd
*)(map
[count
]).pos
);
1213 } /* if new archive element */
1216 bfd_h_put_32(arch
, ((map
[count
]).namidx
),(PTR
) &outs
.s
.string_offset
);
1217 bfd_h_put_32(arch
, firstreal
,(PTR
) &outs
.file_offset
);
1218 bfd_write ((char *)outp
, 1, sizeof (outs
), arch
);
1221 /* now write the strings themselves */
1222 bfd_h_put_32(arch
, stridx
, (PTR
)&temp
);
1223 bfd_write ((PTR
)&temp
, 1, sizeof (temp
), arch
);
1224 for (count
= 0; count
< orl_count
; count
++)
1225 bfd_write (*((map
[count
]).name
), 1, strlen (*((map
[count
]).name
))+1, arch
);
1227 /* The spec sez this should be a newline. But in order to be
1228 bug-compatible for sun's ar we use a null. */
1230 bfd_write("\0",1,1,arch
);
1236 /* A coff armap looks like :
1238 struct ar_hdr with name = '/'
1240 offset of file for symbol 0
1241 offset of file for symbol 1
1243 offset of file for symbol n-1
1252 coff_write_armap (arch
, elength
, map
, symbol_count
, stridx
)
1254 unsigned int elength
;
1256 unsigned int symbol_count
;
1259 /* The size of the ranlib is the number of exported symbols in the
1260 archive * the number of bytes in a int, + an int for the count */
1262 unsigned int ranlibsize
= (symbol_count
* 4) + 4;
1263 unsigned int stringsize
= stridx
;
1264 unsigned int mapsize
= stringsize
+ ranlibsize
;
1265 file_ptr archive_member_file_ptr
;
1266 bfd
*current
= arch
->archive_head
;
1267 bfd
*last_elt
= current
; /* last element arch seen */
1271 int padit
= mapsize
& 1;
1273 if (padit
) mapsize
++;
1275 /* work out where the first object file will go in the archive */
1276 archive_member_file_ptr
= mapsize
+ elength
+ sizeof (struct ar_hdr
) + SARMAG
;
1278 memset ((char *)(&hdr
), 0, sizeof (struct ar_hdr
));
1279 hdr
.ar_name
[0] = '/';
1280 sprintf (hdr
.ar_size
, "%-10d", (int) mapsize
);
1281 sprintf (hdr
.ar_date
, "%ld", (long)time (NULL
));
1282 /* This, at least, is what Intel coff sets the values to.: */
1283 sprintf ((hdr
.ar_uid
), "%d", 0);
1284 sprintf ((hdr
.ar_gid
), "%d", 0);
1285 sprintf ((hdr
.ar_mode
), "%-7o",(unsigned ) 0);
1286 hdr
.ar_fmag
[0] = '`'; hdr
.ar_fmag
[1] = '\n';
1288 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
1289 if (((char *)(&hdr
))[i
] == '\0') (((char *)(&hdr
))[i
]) = ' ';
1291 /* Write the ar header for this item and the number of symbols */
1294 bfd_write ((PTR
)&hdr
, 1, sizeof (struct ar_hdr
), arch
);
1296 bfd_write_bigendian_4byte_int(arch
, symbol_count
);
1298 /* Two passes, first write the file offsets for each symbol -
1299 remembering that each offset is on a two byte boundary
1302 /* Write out the file offset for the file associated with each
1303 symbol, and remember to keep the offsets padded out */
1305 current
= arch
->archive_head
;
1307 while (current
!= (bfd
*)NULL
&& count
< symbol_count
) {
1308 /* For each symbol which is used defined in this object, write out
1309 the object file's address in the archive */
1311 while (((bfd
*)(map
[count
]).pos
) == current
) {
1312 bfd_write_bigendian_4byte_int(arch
, archive_member_file_ptr
);
1315 /* Add size of this archive entry */
1316 archive_member_file_ptr
+= arelt_size (current
) + sizeof (struct
1318 /* remember aboout the even alignment */
1319 archive_member_file_ptr
+= archive_member_file_ptr
% 2;
1320 current
= current
->next
;
1325 /* now write the strings themselves */
1326 for (count
= 0; count
< symbol_count
; count
++) {
1327 bfd_write ((PTR
)*((map
[count
]).name
),
1329 strlen (*((map
[count
]).name
))+1, arch
);
1332 /* The spec sez this should be a newline. But in order to be
1333 bug-compatible for arc960 we use a null. */
1335 bfd_write("\0",1,1,arch
);