1 /* BFD back-end for archive files (libraries).
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 Free Software Foundation, Inc.
5 Written by Cygnus Support. Mostly Gumby Henkel-Wallace's fault.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 @setfilename archive-info
29 An archive (or library) is just another BFD. It has a symbol
30 table, although there's not much a user program will do with it.
32 The big difference between an archive BFD and an ordinary BFD
33 is that the archive doesn't have sections. Instead it has a
34 chain of BFDs that are considered its contents. These BFDs can
35 be manipulated like any other. The BFDs contained in an
36 archive opened for reading will all be opened for reading. You
37 may put either input or output BFDs into an archive opened for
38 output; they will be handled correctly when the archive is closed.
40 Use <<bfd_openr_next_archived_file>> to step through
41 the contents of an archive opened for input. You don't
42 have to read the entire archive if you don't want
43 to! Read it until you find what you want.
45 Archive contents of output BFDs are chained through the
46 <<next>> pointer in a BFD. The first one is findable through
47 the <<archive_head>> slot of the archive. Set it with
48 <<bfd_set_archive_head>> (q.v.). A given BFD may be in only one
49 open output archive at a time.
51 As expected, the BFD archive code is more general than the
52 archive code of any given environment. BFD archives may
53 contain files of different formats (e.g., a.out and coff) and
54 even different architectures. You may even place archives
55 recursively into archives!
57 This can cause unexpected confusion, since some archive
58 formats are more expressive than others. For instance, Intel
59 COFF archives can preserve long filenames; SunOS a.out archives
60 cannot. If you move a file from the first to the second
61 format and back again, the filename may be truncated.
62 Likewise, different a.out environments have different
63 conventions as to how they truncate filenames, whether they
64 preserve directory names in filenames, etc. When
65 interoperating with native tools, be sure your files are
68 Beware: most of these formats do not react well to the
69 presence of spaces in filenames. We do the best we can, but
70 can't always handle this case due to restrictions in the format of
71 archives. Many Unix utilities are braindead in regards to
72 spaces and such in filenames anyway, so this shouldn't be much
75 Archives are supported in BFD in <<archive.c>>.
80 o - all archive elements start on an even boundary, newline padded;
81 o - all arch headers are char *;
82 o - all arch headers are the same size (across architectures).
85 /* Some formats provide a way to cram a long filename into the short
86 (16 chars) space provided by a BSD archive. The trick is: make a
87 special "file" in the front of the archive, sort of like the SYMDEF
88 entry. If the filename is too long to fit, put it in the extended
89 name table, and use its index as the filename. To prevent
90 confusion prepend the index with a space. This means you can't
91 have filenames that start with a space, but then again, many Unix
92 utilities can't handle that anyway.
94 This scheme unfortunately requires that you stand on your head in
95 order to write an archive since you need to put a magic file at the
96 front, and need to touch every entry to do so. C'est la vie.
98 We support two variants of this idea:
99 The SVR4 format (extended name table is named "//"),
100 and an extended pseudo-BSD variant (extended name table is named
101 "ARFILENAMES/"). The origin of the latter format is uncertain.
103 BSD 4.4 uses a third scheme: It writes a long filename
104 directly after the header. This allows 'ar q' to work.
105 We currently can read BSD 4.4 archives, but not write them.
108 /* Summary of archive member names:
110 Symbol table (must be first):
111 "__.SYMDEF " - Symbol table, Berkeley style, produced by ranlib.
112 "/ " - Symbol table, system 5 style.
114 Long name table (must be before regular file members):
115 "// " - Long name table, System 5 R4 style.
116 "ARFILENAMES/ " - Long name table, non-standard extended BSD (not BSD 4.4).
118 Regular file members with short names:
119 "filename.o/ " - Regular file, System 5 style (embedded spaces ok).
120 "filename.o " - Regular file, Berkeley style (no embedded spaces).
122 Regular files with long names (or embedded spaces, for BSD variants):
123 "/18 " - SVR4 style, name at offset 18 in name table.
124 "#1/23 " - Long name (or embedded paces) 23 characters long,
125 BSD 4.4 style, full name follows header.
126 Implemented for reading, not writing.
127 " 18 " - Long name 18 characters long, extended pseudo-BSD.
134 #include "aout/ranlib.h"
142 #define BFD_GNU960_ARMAG(abfd) (BFD_COFF_FILE_P((abfd)) ? ARMAG : ARMAGB)
145 /* Define offsetof for those systems which lack it */
148 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
151 /* We keep a cache of archive filepointers to archive elements to
152 speed up searching the archive by filepos. We only add an entry to
153 the cache when we actually read one. We also don't sort the cache;
154 it's generally short enough to search linearly.
155 Note that the pointers here point to the front of the ar_hdr, not
156 to the front of the contents! */
160 struct ar_cache
*next
;
163 #define ar_padchar(abfd) ((abfd)->xvec->ar_pad_char)
164 #define ar_maxnamelen(abfd) ((abfd)->xvec->ar_max_namelen)
166 #define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data))
167 #define arch_hdr(bfd) ((struct ar_hdr *)arch_eltdata(bfd)->arch_header)
169 static char *get_extended_arelt_filename
PARAMS ((bfd
*arch
,
171 static boolean do_slurp_bsd_armap
PARAMS ((bfd
*abfd
));
172 static boolean do_slurp_coff_armap
PARAMS ((bfd
*abfd
));
173 static const char *normalize
PARAMS ((bfd
*, const char *file
));
174 static struct areltdata
*bfd_ar_hdr_from_filesystem
PARAMS ((bfd
*abfd
,
179 _bfd_generic_mkarchive (abfd
)
182 abfd
->tdata
.aout_ar_data
= ((struct artdata
*)
183 bfd_zalloc (abfd
, sizeof (struct artdata
)));
185 if (bfd_ardata (abfd
) == NULL
)
188 bfd_ardata (abfd
)->cache
= NULL
;
189 bfd_ardata (abfd
)->archive_head
= NULL
;
190 bfd_ardata (abfd
)->symdefs
= NULL
;
191 bfd_ardata (abfd
)->extended_names
= NULL
;
192 bfd_ardata (abfd
)->tdata
= NULL
;
202 symindex bfd_get_next_mapent(bfd *abfd, symindex previous, carsym **sym);
205 Step through archive @var{abfd}'s symbol table (if it
206 has one). Successively update @var{sym} with the next symbol's
207 information, returning that symbol's (internal) index into the
210 Supply <<BFD_NO_MORE_SYMBOLS>> as the @var{previous} entry to get
211 the first one; returns <<BFD_NO_MORE_SYMBOLS>> when you've already
214 A <<carsym>> is a canonical archive symbol. The only
215 user-visible element is its name, a null-terminated string.
219 bfd_get_next_mapent (abfd
, prev
, entry
)
224 if (!bfd_has_map (abfd
))
226 bfd_set_error (bfd_error_invalid_operation
);
227 return BFD_NO_MORE_SYMBOLS
;
230 if (prev
== BFD_NO_MORE_SYMBOLS
)
234 if (prev
>= bfd_ardata (abfd
)->symdef_count
)
235 return BFD_NO_MORE_SYMBOLS
;
237 *entry
= (bfd_ardata (abfd
)->symdefs
+ prev
);
241 /* To be called by backends only */
244 _bfd_create_empty_archive_element_shell (obfd
)
247 return _bfd_new_bfd_contained_in (obfd
);
255 boolean bfd_set_archive_head(bfd *output, bfd *new_head);
258 Set the head of the chain of
259 BFDs contained in the archive @var{output} to @var{new_head}.
263 bfd_set_archive_head (output_archive
, new_head
)
268 output_archive
->archive_head
= new_head
;
273 _bfd_look_for_bfd_in_cache (arch_bfd
, filepos
)
277 struct ar_cache
*current
;
279 for (current
= bfd_ardata (arch_bfd
)->cache
; current
!= NULL
;
280 current
= current
->next
)
281 if (current
->ptr
== filepos
)
282 return current
->arelt
;
287 /* Kind of stupid to call cons for each one, but we don't do too many */
289 _bfd_add_bfd_to_archive_cache (arch_bfd
, filepos
, new_elt
)
290 bfd
*arch_bfd
, *new_elt
;
293 struct ar_cache
*new_cache
= ((struct ar_cache
*)
294 bfd_zalloc (arch_bfd
,
295 sizeof (struct ar_cache
)));
297 if (new_cache
== NULL
)
300 new_cache
->ptr
= filepos
;
301 new_cache
->arelt
= new_elt
;
302 new_cache
->next
= (struct ar_cache
*) NULL
;
303 if (bfd_ardata (arch_bfd
)->cache
== NULL
)
304 bfd_ardata (arch_bfd
)->cache
= new_cache
;
307 struct ar_cache
*current
= bfd_ardata (arch_bfd
)->cache
;
309 while (current
->next
!= NULL
)
310 current
= current
->next
;
311 current
->next
= new_cache
;
317 /* The name begins with space. Hence the rest of the name is an index into
321 get_extended_arelt_filename (arch
, name
)
325 unsigned long index
= 0;
327 /* Should extract string so that I can guarantee not to overflow into
328 the next region, but I'm too lazy. */
330 /* Skip first char, which is '/' in SVR4 or ' ' in some other variants. */
331 index
= strtol (name
+ 1, NULL
, 10);
334 bfd_set_error (bfd_error_malformed_archive
);
338 return bfd_ardata (arch
)->extended_names
+ index
;
341 /* This functions reads an arch header and returns an areltdata pointer, or
344 Presumes the file pointer is already in the right place (ie pointing
345 to the ar_hdr in the file). Moves the file pointer; on success it
346 should be pointing to the front of the file contents; on failure it
347 could have been moved arbitrarily.
351 _bfd_generic_read_ar_hdr (abfd
)
354 return _bfd_generic_read_ar_hdr_mag (abfd
, (const char *) NULL
);
357 /* Alpha ECOFF uses an optional different ARFMAG value, so we have a
358 variant of _bfd_generic_read_ar_hdr which accepts a magic string. */
361 _bfd_generic_read_ar_hdr_mag (abfd
, mag
)
366 char *hdrp
= (char *) &hdr
;
367 unsigned int parsed_size
;
368 struct areltdata
*ared
;
369 char *filename
= NULL
;
370 unsigned int namelen
= 0;
371 unsigned int allocsize
= sizeof (struct areltdata
) + sizeof (struct ar_hdr
);
374 if (bfd_read ((PTR
) hdrp
, 1, sizeof (struct ar_hdr
), abfd
)
375 != sizeof (struct ar_hdr
))
377 if (bfd_get_error () != bfd_error_system_call
)
378 bfd_set_error (bfd_error_no_more_archived_files
);
381 if (strncmp (hdr
.ar_fmag
, ARFMAG
, 2) != 0
383 || strncmp (hdr
.ar_fmag
, mag
, 2) != 0))
385 bfd_set_error (bfd_error_malformed_archive
);
390 parsed_size
= strtol (hdr
.ar_size
, NULL
, 10);
393 bfd_set_error (bfd_error_malformed_archive
);
397 /* Extract the filename from the archive - there are two ways to
398 specify an extended name table, either the first char of the
399 name is a space, or it's a slash. */
400 if ((hdr
.ar_name
[0] == '/'
401 || (hdr
.ar_name
[0] == ' '
402 && memchr (hdr
.ar_name
, '/', ar_maxnamelen (abfd
)) == NULL
))
403 && bfd_ardata (abfd
)->extended_names
!= NULL
)
405 filename
= get_extended_arelt_filename (abfd
, hdr
.ar_name
);
406 if (filename
== NULL
)
408 bfd_set_error (bfd_error_malformed_archive
);
412 /* BSD4.4-style long filename.
413 Only implemented for reading, so far! */
414 else if (hdr
.ar_name
[0] == '#'
415 && hdr
.ar_name
[1] == '1'
416 && hdr
.ar_name
[2] == '/'
417 && isdigit ((unsigned char) hdr
.ar_name
[3]))
419 /* BSD-4.4 extended name */
420 namelen
= atoi (&hdr
.ar_name
[3]);
421 allocsize
+= namelen
+ 1;
422 parsed_size
-= namelen
;
424 allocptr
= bfd_zalloc (abfd
, allocsize
);
425 if (allocptr
== NULL
)
428 + sizeof (struct areltdata
)
429 + sizeof (struct ar_hdr
));
430 if (bfd_read (filename
, 1, namelen
, abfd
) != namelen
)
432 if (bfd_get_error () != bfd_error_system_call
)
433 bfd_set_error (bfd_error_no_more_archived_files
);
436 filename
[namelen
] = '\0';
440 /* We judge the end of the name by looking for '/' or ' '.
441 Note: The SYSV format (terminated by '/') allows embedded
442 spaces, so only look for ' ' if we don't find '/'. */
445 e
= memchr (hdr
.ar_name
, '\0', ar_maxnamelen (abfd
));
448 e
= memchr (hdr
.ar_name
, '/', ar_maxnamelen (abfd
));
450 e
= memchr (hdr
.ar_name
, ' ', ar_maxnamelen (abfd
));
454 namelen
= e
- hdr
.ar_name
;
457 /* If we didn't find a termination character, then the name
458 must be the entire field. */
459 namelen
= ar_maxnamelen (abfd
);
462 allocsize
+= namelen
+ 1;
467 allocptr
= bfd_zalloc (abfd
, allocsize
);
468 if (allocptr
== NULL
)
472 ared
= (struct areltdata
*) allocptr
;
474 ared
->arch_header
= allocptr
+ sizeof (struct areltdata
);
475 memcpy ((char *) ared
->arch_header
, (char *) &hdr
, sizeof (struct ar_hdr
));
476 ared
->parsed_size
= parsed_size
;
478 if (filename
!= NULL
)
479 ared
->filename
= filename
;
482 ared
->filename
= allocptr
+ (sizeof (struct areltdata
) +
483 sizeof (struct ar_hdr
));
485 memcpy (ared
->filename
, hdr
.ar_name
, namelen
);
486 ared
->filename
[namelen
] = '\0';
492 /* This is an internal function; it's mainly used when indexing
493 through the archive symbol table, but also used to get the next
494 element, since it handles the bookkeeping so nicely for us. */
497 _bfd_get_elt_at_filepos (archive
, filepos
)
501 struct areltdata
*new_areldata
;
504 n_nfd
= _bfd_look_for_bfd_in_cache (archive
, filepos
);
508 if (0 > bfd_seek (archive
, filepos
, SEEK_SET
))
511 if ((new_areldata
= (struct areltdata
*) _bfd_read_ar_hdr (archive
)) == NULL
)
514 n_nfd
= _bfd_create_empty_archive_element_shell (archive
);
517 bfd_release (archive
, (PTR
) new_areldata
);
521 n_nfd
->origin
= bfd_tell (archive
);
522 n_nfd
->arelt_data
= (PTR
) new_areldata
;
523 n_nfd
->filename
= new_areldata
->filename
;
525 if (_bfd_add_bfd_to_archive_cache (archive
, filepos
, n_nfd
))
529 bfd_release (archive
, (PTR
) n_nfd
);
530 bfd_release (archive
, (PTR
) new_areldata
);
534 /* Return the BFD which is referenced by the symbol in ABFD indexed by
535 INDEX. INDEX should have been returned by bfd_get_next_mapent. */
538 _bfd_generic_get_elt_at_index (abfd
, index
)
544 entry
= bfd_ardata (abfd
)->symdefs
+ index
;
545 return _bfd_get_elt_at_filepos (abfd
, entry
->file_offset
);
550 bfd_openr_next_archived_file
553 bfd *bfd_openr_next_archived_file(bfd *archive, bfd *previous);
556 Provided a BFD, @var{archive}, containing an archive and NULL, open
557 an input BFD on the first contained element and returns that.
558 Subsequent calls should pass
559 the archive and the previous return value to return a created
560 BFD to the next contained element. NULL is returned when there
565 bfd_openr_next_archived_file (archive
, last_file
)
569 if ((bfd_get_format (archive
) != bfd_archive
) ||
570 (archive
->direction
== write_direction
))
572 bfd_set_error (bfd_error_invalid_operation
);
576 return BFD_SEND (archive
,
577 openr_next_archived_file
,
583 bfd_generic_openr_next_archived_file (archive
, last_file
)
590 filestart
= bfd_ardata (archive
)->first_file_filepos
;
593 unsigned int size
= arelt_size (last_file
);
594 /* Pad to an even boundary...
595 Note that last_file->origin can be odd in the case of
596 BSD-4.4-style element with a long odd size. */
597 filestart
= last_file
->origin
+ size
;
598 filestart
+= filestart
% 2;
601 return _bfd_get_elt_at_filepos (archive
, filestart
);
605 bfd_generic_archive_p (abfd
)
608 struct artdata
*tdata_hold
;
609 char armag
[SARMAG
+ 1];
611 tdata_hold
= abfd
->tdata
.aout_ar_data
;
613 if (bfd_read ((PTR
) armag
, 1, SARMAG
, abfd
) != SARMAG
)
615 if (bfd_get_error () != bfd_error_system_call
)
616 bfd_set_error (bfd_error_wrong_format
);
621 if (strncmp (armag
, BFD_GNU960_ARMAG (abfd
), SARMAG
) != 0)
624 if (strncmp (armag
, ARMAG
, SARMAG
) != 0 &&
625 strncmp (armag
, ARMAGB
, SARMAG
) != 0)
629 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
630 involves a cast, we can't do it as the left operand of assignment. */
631 abfd
->tdata
.aout_ar_data
= ((struct artdata
*)
632 bfd_zalloc (abfd
, sizeof (struct artdata
)));
634 if (bfd_ardata (abfd
) == NULL
)
637 bfd_ardata (abfd
)->first_file_filepos
= SARMAG
;
638 bfd_ardata (abfd
)->cache
= NULL
;
639 bfd_ardata (abfd
)->archive_head
= NULL
;
640 bfd_ardata (abfd
)->symdefs
= NULL
;
641 bfd_ardata (abfd
)->extended_names
= NULL
;
642 bfd_ardata (abfd
)->tdata
= NULL
;
644 if (!BFD_SEND (abfd
, _bfd_slurp_armap
, (abfd
)))
646 bfd_release (abfd
, bfd_ardata (abfd
));
647 abfd
->tdata
.aout_ar_data
= tdata_hold
;
648 if (bfd_get_error () != bfd_error_system_call
)
649 bfd_set_error (bfd_error_wrong_format
);
653 if (!BFD_SEND (abfd
, _bfd_slurp_extended_name_table
, (abfd
)))
655 bfd_release (abfd
, bfd_ardata (abfd
));
656 abfd
->tdata
.aout_ar_data
= tdata_hold
;
657 if (bfd_get_error () != bfd_error_system_call
)
658 bfd_set_error (bfd_error_wrong_format
);
662 if (bfd_has_map (abfd
))
666 /* This archive has a map, so we may presume that the contents
667 are object files. Make sure that if the first file in the
668 archive can be recognized as an object file, it is for this
669 target. If not, assume that this is the wrong format. If
670 the first file is not an object file, somebody is doing
671 something weird, and we permit it so that ar -t will work.
673 This is done because any normal format will recognize any
674 normal archive, regardless of the format of the object files.
675 We do accept an empty archive. */
677 first
= bfd_openr_next_archived_file (abfd
, (bfd
*) NULL
);
682 first
->target_defaulted
= false;
684 if (bfd_check_format (first
, bfd_object
)
685 && first
->xvec
!= abfd
->xvec
)
688 /* We ought to close `first' here, but we can't, because
689 we have no way to remove it from the archive cache.
690 It's close to impossible to figure out when we can
691 release bfd_ardata. FIXME. */
692 (void) bfd_close (first
);
693 bfd_release (abfd
, bfd_ardata (abfd
));
694 abfd
->tdata
.aout_ar_data
= tdata_hold
;
696 bfd_set_error (bfd_error_wrong_object_format
);
699 /* And we ought to close `first' here too. */
706 /* Some constants for a 32 bit BSD archive structure. We do not
707 support 64 bit archives presently; so far as I know, none actually
708 exist. Supporting them would require changing these constants, and
709 changing some bfd_h_get_32 to bfd_h_get_64. */
711 /* The size of an external symdef structure. */
712 #define BSD_SYMDEF_SIZE 8
714 /* The offset from the start of a symdef structure to the file offset. */
715 #define BSD_SYMDEF_OFFSET_SIZE 4
717 /* The size of the symdef count. */
718 #define BSD_SYMDEF_COUNT_SIZE 4
720 /* The size of the string count. */
721 #define BSD_STRING_COUNT_SIZE 4
723 /* Returns false on error, true otherwise */
726 do_slurp_bsd_armap (abfd
)
729 struct areltdata
*mapdata
;
730 unsigned int counter
;
731 bfd_byte
*raw_armap
, *rbase
;
732 struct artdata
*ardata
= bfd_ardata (abfd
);
734 unsigned int parsed_size
;
737 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
740 parsed_size
= mapdata
->parsed_size
;
741 bfd_release (abfd
, (PTR
) mapdata
); /* Don't need it any more. */
743 raw_armap
= (bfd_byte
*) bfd_zalloc (abfd
, parsed_size
);
744 if (raw_armap
== (bfd_byte
*) NULL
)
747 if (bfd_read ((PTR
) raw_armap
, 1, parsed_size
, abfd
) != parsed_size
)
749 if (bfd_get_error () != bfd_error_system_call
)
750 bfd_set_error (bfd_error_malformed_archive
);
752 bfd_release (abfd
, (PTR
) raw_armap
);
756 ardata
->symdef_count
= bfd_h_get_32 (abfd
, raw_armap
) / BSD_SYMDEF_SIZE
;
758 if (ardata
->symdef_count
* BSD_SYMDEF_SIZE
>
759 parsed_size
- BSD_SYMDEF_COUNT_SIZE
)
761 /* Probably we're using the wrong byte ordering. */
762 bfd_set_error (bfd_error_wrong_format
);
767 rbase
= raw_armap
+ BSD_SYMDEF_COUNT_SIZE
;
768 stringbase
= ((char *) rbase
769 + ardata
->symdef_count
* BSD_SYMDEF_SIZE
770 + BSD_STRING_COUNT_SIZE
);
771 ardata
->symdefs
= (carsym
*) bfd_alloc (abfd
,
772 (ardata
->symdef_count
774 if (!ardata
->symdefs
)
777 for (counter
= 0, set
= ardata
->symdefs
;
778 counter
< ardata
->symdef_count
;
779 counter
++, set
++, rbase
+= BSD_SYMDEF_SIZE
)
781 set
->name
= bfd_h_get_32 (abfd
, rbase
) + stringbase
;
782 set
->file_offset
= bfd_h_get_32 (abfd
, rbase
+ BSD_SYMDEF_OFFSET_SIZE
);
785 ardata
->first_file_filepos
= bfd_tell (abfd
);
786 /* Pad to an even boundary if you have to. */
787 ardata
->first_file_filepos
+= (ardata
->first_file_filepos
) % 2;
788 /* FIXME, we should provide some way to free raw_ardata when
789 we are done using the strings from it. For now, it seems
790 to be allocated on an objalloc anyway... */
791 bfd_has_map (abfd
) = true;
795 /* Returns false on error, true otherwise. */
798 do_slurp_coff_armap (abfd
)
801 struct areltdata
*mapdata
;
802 int *raw_armap
, *rawptr
;
803 struct artdata
*ardata
= bfd_ardata (abfd
);
805 unsigned int stringsize
;
806 unsigned int parsed_size
;
808 unsigned int nsymz
; /* Number of symbols in armap. */
809 bfd_vma (*swap
) PARAMS ((const bfd_byte
*));
810 char int_buf
[sizeof (long)];
811 unsigned int carsym_size
, ptrsize
, i
;
813 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
816 parsed_size
= mapdata
->parsed_size
;
817 bfd_release (abfd
, (PTR
) mapdata
); /* Don't need it any more. */
819 if (bfd_read ((PTR
) int_buf
, 1, 4, abfd
) != 4)
821 if (bfd_get_error () != bfd_error_system_call
)
822 bfd_set_error (bfd_error_malformed_archive
);
825 /* It seems that all numeric information in a coff archive is always
826 in big endian format, nomatter the host or target. */
828 nsymz
= bfd_getb32 ((PTR
) int_buf
);
829 stringsize
= parsed_size
- (4 * nsymz
) - 4;
832 /* ... except that some archive formats are broken, and it may be our
833 fault - the i960 little endian coff sometimes has big and sometimes
834 little, because our tools changed. Here's a horrible hack to clean
837 if (stringsize
> 0xfffff
838 && bfd_get_arch (abfd
) == bfd_arch_i960
839 && bfd_get_flavour (abfd
) == bfd_target_coff_flavour
)
841 /* This looks dangerous, let's do it the other way around. */
842 nsymz
= bfd_getl32 ((PTR
) int_buf
);
843 stringsize
= parsed_size
- (4 * nsymz
) - 4;
848 /* The coff armap must be read sequentially. So we construct a
849 bsd-style one in core all at once, for simplicity. */
851 carsym_size
= (nsymz
* sizeof (carsym
));
852 ptrsize
= (4 * nsymz
);
854 ardata
->symdefs
= (carsym
*) bfd_zalloc (abfd
, carsym_size
+ stringsize
+ 1);
855 if (ardata
->symdefs
== NULL
)
857 carsyms
= ardata
->symdefs
;
858 stringbase
= ((char *) ardata
->symdefs
) + carsym_size
;
860 /* Allocate and read in the raw offsets. */
861 raw_armap
= (int *) bfd_alloc (abfd
, ptrsize
);
862 if (raw_armap
== NULL
)
863 goto release_symdefs
;
864 if (bfd_read ((PTR
) raw_armap
, 1, ptrsize
, abfd
) != ptrsize
865 || bfd_read ((PTR
) stringbase
, 1, stringsize
, abfd
) != stringsize
)
867 if (bfd_get_error () != bfd_error_system_call
)
868 bfd_set_error (bfd_error_malformed_archive
);
869 goto release_raw_armap
;
872 /* OK, build the carsyms. */
873 for (i
= 0; i
< nsymz
; i
++)
875 rawptr
= raw_armap
+ i
;
876 carsyms
->file_offset
= swap ((PTR
) rawptr
);
877 carsyms
->name
= stringbase
;
878 stringbase
+= strlen (stringbase
) + 1;
883 ardata
->symdef_count
= nsymz
;
884 ardata
->first_file_filepos
= bfd_tell (abfd
);
885 /* Pad to an even boundary if you have to. */
886 ardata
->first_file_filepos
+= (ardata
->first_file_filepos
) % 2;
888 bfd_has_map (abfd
) = true;
889 bfd_release (abfd
, (PTR
) raw_armap
);
891 /* Check for a second archive header (as used by PE). */
893 struct areltdata
*tmp
;
895 bfd_seek (abfd
, ardata
->first_file_filepos
, SEEK_SET
);
896 tmp
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
899 if (tmp
->arch_header
[0] == '/'
900 && tmp
->arch_header
[1] == ' ')
902 ardata
->first_file_filepos
+=
903 (tmp
->parsed_size
+ sizeof (struct ar_hdr
) + 1) & ~1;
905 bfd_release (abfd
, tmp
);
912 bfd_release (abfd
, (PTR
) raw_armap
);
914 bfd_release (abfd
, (PTR
) (ardata
)->symdefs
);
918 /* This routine can handle either coff-style or bsd-style armaps.
919 Returns false on error, true otherwise */
922 bfd_slurp_armap (abfd
)
926 int i
= bfd_read ((PTR
) nextname
, 1, 16, abfd
);
933 if (bfd_seek (abfd
, (file_ptr
) - 16, SEEK_CUR
) != 0)
936 if (!strncmp (nextname
, "__.SYMDEF ", 16)
937 || !strncmp (nextname
, "__.SYMDEF/ ", 16)) /* old Linux archives */
938 return do_slurp_bsd_armap (abfd
);
939 else if (!strncmp (nextname
, "/ ", 16))
940 return do_slurp_coff_armap (abfd
);
941 else if (!strncmp (nextname
, "/SYM64/ ", 16))
943 /* Irix 6 archive--must be recognized by code in elf64-mips.c. */
944 bfd_set_error (bfd_error_wrong_format
);
948 bfd_has_map (abfd
) = false;
952 /* Returns false on error, true otherwise */
953 /* flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
954 header is in a slightly different order and the map name is '/'.
955 This flavour is used by hp300hpux. */
957 #define HPUX_SYMDEF_COUNT_SIZE 2
960 bfd_slurp_bsd_armap_f2 (abfd
)
963 struct areltdata
*mapdata
;
965 unsigned int counter
;
966 bfd_byte
*raw_armap
, *rbase
;
967 struct artdata
*ardata
= bfd_ardata (abfd
);
969 unsigned int stringsize
;
971 int i
= bfd_read ((PTR
) nextname
, 1, 16, abfd
);
978 /* The archive has at least 16 bytes in it. */
979 if (bfd_seek (abfd
, -16L, SEEK_CUR
) != 0)
982 if (!strncmp (nextname
, "__.SYMDEF ", 16)
983 || !strncmp (nextname
, "__.SYMDEF/ ", 16)) /* old Linux archives */
984 return do_slurp_bsd_armap (abfd
);
986 if (strncmp (nextname
, "/ ", 16))
988 bfd_has_map (abfd
) = false;
992 mapdata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
996 raw_armap
= (bfd_byte
*) bfd_zalloc (abfd
, mapdata
->parsed_size
);
997 if (raw_armap
== NULL
)
1000 bfd_release (abfd
, (PTR
) mapdata
);
1004 if (bfd_read ((PTR
) raw_armap
, 1, mapdata
->parsed_size
, abfd
) !=
1005 mapdata
->parsed_size
)
1007 if (bfd_get_error () != bfd_error_system_call
)
1008 bfd_set_error (bfd_error_malformed_archive
);
1010 bfd_release (abfd
, (PTR
) raw_armap
);
1014 ardata
->symdef_count
= bfd_h_get_16 (abfd
, (PTR
) raw_armap
);
1016 if (ardata
->symdef_count
* BSD_SYMDEF_SIZE
1017 > mapdata
->parsed_size
- HPUX_SYMDEF_COUNT_SIZE
)
1019 /* Probably we're using the wrong byte ordering. */
1020 bfd_set_error (bfd_error_wrong_format
);
1026 stringsize
= bfd_h_get_32 (abfd
, raw_armap
+ HPUX_SYMDEF_COUNT_SIZE
);
1027 /* Skip sym count and string sz. */
1028 stringbase
= ((char *) raw_armap
1029 + HPUX_SYMDEF_COUNT_SIZE
1030 + BSD_STRING_COUNT_SIZE
);
1031 rbase
= (bfd_byte
*) stringbase
+ stringsize
;
1032 ardata
->symdefs
= (carsym
*) bfd_alloc (abfd
,
1033 (ardata
->symdef_count
1034 * BSD_SYMDEF_SIZE
));
1035 if (!ardata
->symdefs
)
1038 for (counter
= 0, set
= ardata
->symdefs
;
1039 counter
< ardata
->symdef_count
;
1040 counter
++, set
++, rbase
+= BSD_SYMDEF_SIZE
)
1042 set
->name
= bfd_h_get_32 (abfd
, rbase
) + stringbase
;
1043 set
->file_offset
= bfd_h_get_32 (abfd
, rbase
+ BSD_SYMDEF_OFFSET_SIZE
);
1046 ardata
->first_file_filepos
= bfd_tell (abfd
);
1047 /* Pad to an even boundary if you have to. */
1048 ardata
->first_file_filepos
+= (ardata
->first_file_filepos
) % 2;
1049 /* FIXME, we should provide some way to free raw_ardata when
1050 we are done using the strings from it. For now, it seems
1051 to be allocated on an objalloc anyway... */
1052 bfd_has_map (abfd
) = true;
1056 /** Extended name table.
1058 Normally archives support only 14-character filenames.
1060 Intel has extended the format: longer names are stored in a special
1061 element (the first in the archive, or second if there is an armap);
1062 the name in the ar_hdr is replaced by <space><index into filename
1063 element>. Index is the P.R. of an int (decimal). Data General have
1064 extended the format by using the prefix // for the special element. */
1066 /* Returns false on error, true otherwise. */
1069 _bfd_slurp_extended_name_table (abfd
)
1073 struct areltdata
*namedata
;
1075 /* FIXME: Formatting sucks here, and in case of failure of BFD_READ,
1076 we probably don't want to return true. */
1077 bfd_seek (abfd
, bfd_ardata (abfd
)->first_file_filepos
, SEEK_SET
);
1078 if (bfd_read ((PTR
) nextname
, 1, 16, abfd
) == 16)
1080 if (bfd_seek (abfd
, (file_ptr
) - 16, SEEK_CUR
) != 0)
1083 if (strncmp (nextname
, "ARFILENAMES/ ", 16) != 0 &&
1084 strncmp (nextname
, "// ", 16) != 0)
1086 bfd_ardata (abfd
)->extended_names
= NULL
;
1090 namedata
= (struct areltdata
*) _bfd_read_ar_hdr (abfd
);
1091 if (namedata
== NULL
)
1094 bfd_ardata (abfd
)->extended_names
=
1095 bfd_zalloc (abfd
, namedata
->parsed_size
);
1096 if (bfd_ardata (abfd
)->extended_names
== NULL
)
1099 bfd_release (abfd
, (PTR
) namedata
);
1103 if (bfd_read ((PTR
) bfd_ardata (abfd
)->extended_names
, 1,
1104 namedata
->parsed_size
, abfd
) != namedata
->parsed_size
)
1106 if (bfd_get_error () != bfd_error_system_call
)
1107 bfd_set_error (bfd_error_malformed_archive
);
1108 bfd_release (abfd
, (PTR
) (bfd_ardata (abfd
)->extended_names
));
1109 bfd_ardata (abfd
)->extended_names
= NULL
;
1113 /* Since the archive is supposed to be printable if it contains
1114 text, the entries in the list are newline-padded, not null
1115 padded. In SVR4-style archives, the names also have a
1116 trailing '/'. DOS/NT created archive often have \ in them
1117 We'll fix all problems here.. */
1119 char *temp
= bfd_ardata (abfd
)->extended_names
;
1120 char *limit
= temp
+ namedata
->parsed_size
;
1121 for (; temp
< limit
; ++temp
)
1123 if (*temp
== '\012')
1124 temp
[temp
[-1] == '/' ? -1 : 0] = '\0';
1130 /* Pad to an even boundary if you have to. */
1131 bfd_ardata (abfd
)->first_file_filepos
= bfd_tell (abfd
);
1132 bfd_ardata (abfd
)->first_file_filepos
+=
1133 (bfd_ardata (abfd
)->first_file_filepos
) % 2;
1135 /* FIXME, we can't release namedata here because it was allocated
1136 below extended_names on the objalloc... */
1138 bfd_release (abfd
, namedata
);
1146 /* Return a copy of the stuff in the filename between any :]> and a
1150 normalize (abfd
, file
)
1158 first
= file
+ strlen (file
) - 1;
1161 while (first
!= file
)
1165 if (*first
== ':' || *first
== ']' || *first
== '>')
1173 copy
= (char *) bfd_alloc (abfd
, last
- first
+ 1);
1177 memcpy (copy
, first
, last
- first
);
1178 copy
[last
- first
] = 0;
1185 normalize (abfd
, file
)
1186 bfd
*abfd ATTRIBUTE_UNUSED
;
1189 const char *filename
= strrchr (file
, '/');
1191 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1193 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */
1194 char *bslash
= strrchr (file
, '\\');
1195 if (filename
== NULL
|| (bslash
!= NULL
&& bslash
> filename
))
1197 if (filename
== NULL
&& file
[0] != '\0' && file
[1] == ':')
1198 filename
= file
+ 1;
1201 if (filename
!= (char *) NULL
)
1209 /* Build a BFD style extended name table. */
1212 _bfd_archive_bsd_construct_extended_name_table (abfd
, tabloc
, tablen
, name
)
1215 bfd_size_type
*tablen
;
1218 *name
= "ARFILENAMES/";
1219 return _bfd_construct_extended_name_table (abfd
, false, tabloc
, tablen
);
1222 /* Build an SVR4 style extended name table. */
1225 _bfd_archive_coff_construct_extended_name_table (abfd
, tabloc
, tablen
, name
)
1228 bfd_size_type
*tablen
;
1232 return _bfd_construct_extended_name_table (abfd
, true, tabloc
, tablen
);
1235 /* Follows archive_head and produces an extended name table if
1236 necessary. Returns (in tabloc) a pointer to an extended name
1237 table, and in tablen the length of the table. If it makes an entry
1238 it clobbers the filename so that the element may be written without
1239 further massage. Returns true if it ran successfully, false if
1240 something went wrong. A successful return may still involve a
1241 zero-length tablen! */
1244 _bfd_construct_extended_name_table (abfd
, trailing_slash
, tabloc
, tablen
)
1246 boolean trailing_slash
;
1248 bfd_size_type
*tablen
;
1250 unsigned int maxname
= abfd
->xvec
->ar_max_namelen
;
1251 unsigned int total_namelen
= 0;
1257 /* Figure out how long the table should be. */
1258 for (current
= abfd
->archive_head
; current
!= NULL
; current
= current
->next
)
1261 unsigned int thislen
;
1263 normal
= normalize (current
, current
->filename
);
1267 thislen
= strlen (normal
);
1269 if (thislen
> maxname
1270 && (bfd_get_file_flags (abfd
) & BFD_TRADITIONAL_FORMAT
) != 0)
1273 if (thislen
> maxname
)
1275 /* Add one to leave room for \n. */
1276 total_namelen
+= thislen
+ 1;
1279 /* Leave room for trailing slash. */
1285 struct ar_hdr
*hdr
= arch_hdr (current
);
1286 if (strncmp (normal
, hdr
->ar_name
, thislen
) != 0
1287 || (thislen
< sizeof hdr
->ar_name
1288 && hdr
->ar_name
[thislen
] != ar_padchar (current
)))
1290 /* Must have been using extended format even though it
1291 didn't need to. Fix it to use normal format. */
1292 memcpy (hdr
->ar_name
, normal
, thislen
);
1293 if (thislen
< maxname
1294 || (thislen
== maxname
&& thislen
< sizeof hdr
->ar_name
))
1295 hdr
->ar_name
[thislen
] = ar_padchar (current
);
1300 if (total_namelen
== 0)
1303 *tabloc
= bfd_zalloc (abfd
, total_namelen
);
1304 if (*tabloc
== NULL
)
1307 *tablen
= total_namelen
;
1310 for (current
= abfd
->archive_head
; current
!= NULL
; current
=
1314 unsigned int thislen
;
1316 normal
= normalize (current
, current
->filename
);
1320 thislen
= strlen (normal
);
1321 if (thislen
> maxname
)
1323 /* Works for now; may need to be re-engineered if we
1324 encounter an oddball archive format and want to
1325 generalise this hack. */
1326 struct ar_hdr
*hdr
= arch_hdr (current
);
1327 strcpy (strptr
, normal
);
1328 if (! trailing_slash
)
1329 strptr
[thislen
] = '\012';
1332 strptr
[thislen
] = '/';
1333 strptr
[thislen
+ 1] = '\012';
1335 hdr
->ar_name
[0] = ar_padchar (current
);
1336 /* We know there will always be enough room (one of the few
1337 cases where you may safely use sprintf). */
1338 sprintf ((hdr
->ar_name
) + 1, "%-d", (unsigned) (strptr
- *tabloc
));
1339 /* Kinda Kludgy. We should just use the returned value of
1340 sprintf but not all implementations get this right. */
1342 char *temp
= hdr
->ar_name
+ 2;
1343 for (; temp
< hdr
->ar_name
+ maxname
; temp
++)
1347 strptr
+= thislen
+ 1;
1356 /** A couple of functions for creating ar_hdrs */
1358 #ifdef HPUX_LARGE_AR_IDS
1359 /* Function to encode large UID/GID values according to HP. */
1362 hpux_uid_gid_encode (str
, id
)
1368 str
[5] = '@' + (id
& 3);
1371 for (cnt
= 4; cnt
>= 0; ++cnt
, id
>>= 6)
1372 str
[cnt
] = ' ' + (id
& 0x3f);
1374 #endif /* HPUX_LARGE_AR_IDS */
1384 /* Takes a filename, returns an arelt_data for it, or NULL if it can't
1385 make one. The filename must refer to a filename in the filesystem.
1386 The filename field of the ar_hdr will NOT be initialized. If member
1387 is set, and it's an in-memory bfd, we fake it. */
1389 static struct areltdata
*
1390 bfd_ar_hdr_from_filesystem (abfd
, filename
, member
)
1392 const char *filename
;
1396 struct areltdata
*ared
;
1400 if (member
&& (member
->flags
& BFD_IN_MEMORY
) != 0)
1402 /* Assume we just "made" the member, and fake it. */
1403 struct bfd_in_memory
*bim
= (struct bfd_in_memory
*) member
->iostream
;
1404 time (&status
.st_mtime
);
1405 status
.st_uid
= getuid ();
1406 status
.st_gid
= getgid ();
1407 status
.st_mode
= 0644;
1408 status
.st_size
= bim
->size
;
1410 else if (stat (filename
, &status
) != 0)
1412 bfd_set_error (bfd_error_system_call
);
1416 ared
= (struct areltdata
*) bfd_zalloc (abfd
, sizeof (struct ar_hdr
) +
1417 sizeof (struct areltdata
));
1420 hdr
= (struct ar_hdr
*) (((char *) ared
) + sizeof (struct areltdata
));
1422 /* ar headers are space padded, not null padded! */
1423 memset ((PTR
) hdr
, ' ', sizeof (struct ar_hdr
));
1425 strncpy (hdr
->ar_fmag
, ARFMAG
, 2);
1427 /* Goddamned sprintf doesn't permit MAXIMUM field lengths. */
1428 sprintf ((hdr
->ar_date
), "%-12ld", (long) status
.st_mtime
);
1429 #ifdef HPUX_LARGE_AR_IDS
1430 /* HP has a very "special" way to handle UID/GID's with numeric values
1432 if (status
.st_uid
> 99999)
1433 hpux_uid_gid_encode (hdr
->ar_gid
, (long) status
.st_uid
);
1436 sprintf ((hdr
->ar_uid
), "%ld", (long) status
.st_uid
);
1437 #ifdef HPUX_LARGE_AR_IDS
1438 /* HP has a very "special" way to handle UID/GID's with numeric values
1440 if (status
.st_gid
> 99999)
1441 hpux_uid_gid_encode (hdr
->ar_uid
, (long) status
.st_gid
);
1444 sprintf ((hdr
->ar_gid
), "%ld", (long) status
.st_gid
);
1445 sprintf ((hdr
->ar_mode
), "%-8o", (unsigned int) status
.st_mode
);
1446 sprintf ((hdr
->ar_size
), "%-10ld", (long) status
.st_size
);
1447 /* Correct for a lossage in sprintf whereby it null-terminates. I cannot
1448 understand how these C losers could design such a ramshackle bunch of
1450 temp
= (char *) hdr
;
1451 temp1
= temp
+ sizeof (struct ar_hdr
) - 2;
1452 for (; temp
< temp1
; temp
++)
1457 strncpy (hdr
->ar_fmag
, ARFMAG
, 2);
1458 ared
->parsed_size
= status
.st_size
;
1459 ared
->arch_header
= (char *) hdr
;
1464 /* This is magic required by the "ar" program. Since it's
1465 undocumented, it's undocumented. You may think that it would take
1466 a strong stomach to write this, and it does, but it takes even a
1467 stronger stomach to try to code around such a thing! */
1469 struct ar_hdr
*bfd_special_undocumented_glue
PARAMS ((bfd
*, const char *));
1472 bfd_special_undocumented_glue (abfd
, filename
)
1474 const char *filename
;
1476 struct areltdata
*ar_elt
= bfd_ar_hdr_from_filesystem (abfd
, filename
, 0);
1479 return (struct ar_hdr
*) ar_elt
->arch_header
;
1482 /* Analogous to stat call. */
1485 bfd_generic_stat_arch_elt (abfd
, buf
)
1492 if (abfd
->arelt_data
== NULL
)
1494 bfd_set_error (bfd_error_invalid_operation
);
1498 hdr
= arch_hdr (abfd
);
1500 #define foo(arelt, stelt, size) \
1501 buf->stelt = strtol (hdr->arelt, &aloser, size); \
1502 if (aloser == hdr->arelt) \
1505 /* Some platforms support special notations for large IDs. */
1506 #ifdef HPUX_LARGE_AR_IDS
1507 # define foo2(arelt, stelt, size) \
1508 if (hdr->arelt[5] == ' ') \
1510 foo (arelt, stelt, size); \
1515 for (buf->stelt = cnt = 0; cnt < 5; ++cnt) \
1517 if (hdr->arelt[cnt] < ' ' || hdr->arelt[cnt] > ' ' + 0x3f) \
1520 buf->stelt += hdr->arelt[cnt] - ' '; \
1522 if (hdr->arelt[5] < '@' || hdr->arelt[5] > '@' + 3) \
1525 buf->stelt += hdr->arelt[5] - '@'; \
1528 # define foo2(arelt, stelt, size) foo (arelt, stelt, size)
1531 foo (ar_date
, st_mtime
, 10);
1532 foo2 (ar_uid
, st_uid
, 10);
1533 foo2 (ar_gid
, st_gid
, 10);
1534 foo (ar_mode
, st_mode
, 8);
1536 buf
->st_size
= arch_eltdata (abfd
)->parsed_size
;
1542 bfd_dont_truncate_arname (abfd
, pathname
, arhdr
)
1544 CONST
char *pathname
;
1547 /* FIXME: This interacts unpleasantly with ar's quick-append option.
1548 Fortunately ic960 users will never use that option. Fixing this
1549 is very hard; fortunately I know how to do it and will do so once
1550 intel's release is out the door. */
1552 struct ar_hdr
*hdr
= (struct ar_hdr
*) arhdr
;
1554 const char *filename
;
1555 size_t maxlen
= ar_maxnamelen (abfd
);
1557 if ((bfd_get_file_flags (abfd
) & BFD_TRADITIONAL_FORMAT
) != 0)
1559 bfd_bsd_truncate_arname (abfd
, pathname
, arhdr
);
1563 filename
= normalize (abfd
, pathname
);
1564 if (filename
== NULL
)
1570 length
= strlen (filename
);
1572 if (length
<= maxlen
)
1573 memcpy (hdr
->ar_name
, filename
, length
);
1575 /* Add the padding character if there is room for it. */
1577 || (length
== maxlen
&& length
< sizeof hdr
->ar_name
))
1578 (hdr
->ar_name
)[length
] = ar_padchar (abfd
);
1582 bfd_bsd_truncate_arname (abfd
, pathname
, arhdr
)
1584 CONST
char *pathname
;
1587 struct ar_hdr
*hdr
= (struct ar_hdr
*) arhdr
;
1589 CONST
char *filename
= strrchr (pathname
, '/');
1590 int maxlen
= ar_maxnamelen (abfd
);
1592 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1594 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */
1595 char *bslash
= strrchr (pathname
, '\\');
1596 if (filename
== NULL
|| (bslash
!= NULL
&& bslash
> filename
))
1598 if (filename
== NULL
&& pathname
[0] != '\0' && pathname
[1] == ':')
1599 filename
= pathname
+ 1;
1603 if (filename
== NULL
)
1604 filename
= pathname
;
1608 length
= strlen (filename
);
1610 if (length
<= maxlen
)
1611 memcpy (hdr
->ar_name
, filename
, length
);
1614 /* pathname: meet procrustes */
1615 memcpy (hdr
->ar_name
, filename
, maxlen
);
1619 if (length
< maxlen
)
1620 (hdr
->ar_name
)[length
] = ar_padchar (abfd
);
1623 /* Store name into ar header. Truncates the name to fit.
1624 1> strip pathname to be just the basename.
1625 2> if it's short enuf to fit, stuff it in.
1626 3> If it doesn't end with .o, truncate it to fit
1627 4> truncate it before the .o, append .o, stuff THAT in. */
1629 /* This is what gnu ar does. It's better but incompatible with the
1633 bfd_gnu_truncate_arname (abfd
, pathname
, arhdr
)
1635 CONST
char *pathname
;
1638 struct ar_hdr
*hdr
= (struct ar_hdr
*) arhdr
;
1640 CONST
char *filename
= strrchr (pathname
, '/');
1641 int maxlen
= ar_maxnamelen (abfd
);
1643 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1645 /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */
1646 char *bslash
= strrchr (pathname
, '\\');
1647 if (filename
== NULL
|| (bslash
!= NULL
&& bslash
> filename
))
1649 if (filename
== NULL
&& pathname
[0] != '\0' && pathname
[1] == ':')
1650 filename
= pathname
+ 1;
1654 if (filename
== NULL
)
1655 filename
= pathname
;
1659 length
= strlen (filename
);
1661 if (length
<= maxlen
)
1662 memcpy (hdr
->ar_name
, filename
, length
);
1664 { /* pathname: meet procrustes */
1665 memcpy (hdr
->ar_name
, filename
, maxlen
);
1666 if ((filename
[length
- 2] == '.') && (filename
[length
- 1] == 'o'))
1668 hdr
->ar_name
[maxlen
- 2] = '.';
1669 hdr
->ar_name
[maxlen
- 1] = 'o';
1675 (hdr
->ar_name
)[length
] = ar_padchar (abfd
);
1678 /* The BFD is open for write and has its format set to bfd_archive. */
1681 _bfd_write_archive_contents (arch
)
1685 char *etable
= NULL
;
1686 bfd_size_type elength
= 0;
1687 const char *ename
= NULL
;
1688 boolean makemap
= bfd_has_map (arch
);
1689 boolean hasobjects
= false; /* If no .o's, don't bother to make a map. */
1690 bfd_size_type wrote
;
1694 /* Verify the viability of all entries; if any of them live in the
1695 filesystem (as opposed to living in an archive open for input)
1696 then construct a fresh ar_hdr for them. */
1697 for (current
= arch
->archive_head
; current
; current
= current
->next
)
1699 /* This check is checking the bfds for the objects we're reading
1700 from (which are usually either an object file or archive on
1701 disk), not the archive entries we're writing to. We don't
1702 actually create bfds for the archive members, we just copy
1703 them byte-wise when we write out the archive. */
1704 if (bfd_write_p (current
))
1706 bfd_set_error (bfd_error_invalid_operation
);
1709 if (!current
->arelt_data
)
1711 current
->arelt_data
=
1712 (PTR
) bfd_ar_hdr_from_filesystem (arch
, current
->filename
, current
);
1713 if (!current
->arelt_data
)
1716 /* Put in the file name. */
1717 BFD_SEND (arch
, _bfd_truncate_arname
, (arch
,
1719 (char *) arch_hdr (current
)));
1722 if (makemap
&& ! hasobjects
)
1723 { /* Don't bother if we won't make a map! */
1724 if ((bfd_check_format (current
, bfd_object
))
1725 #if 0 /* FIXME -- these are not set correctly */
1726 && ((bfd_get_file_flags (current
) & HAS_SYMS
))
1733 if (!BFD_SEND (arch
, _bfd_construct_extended_name_table
,
1734 (arch
, &etable
, &elength
, &ename
)))
1737 if (bfd_seek (arch
, (file_ptr
) 0, SEEK_SET
) != 0)
1740 wrote
= bfd_write (BFD_GNU960_ARMAG (arch
), 1, SARMAG
, arch
);
1742 wrote
= bfd_write (ARMAG
, 1, SARMAG
, arch
);
1744 if (wrote
!= SARMAG
)
1747 if (makemap
&& hasobjects
)
1749 if (_bfd_compute_and_write_armap (arch
, elength
) != true)
1757 memset ((char *) (&hdr
), 0, sizeof (struct ar_hdr
));
1758 strcpy (hdr
.ar_name
, ename
);
1759 /* Round size up to even number in archive header. */
1760 sprintf (&(hdr
.ar_size
[0]), "%-10d",
1761 (int) ((elength
+ 1) & ~1));
1762 strncpy (hdr
.ar_fmag
, ARFMAG
, 2);
1763 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
1764 if (((char *) (&hdr
))[i
] == '\0')
1765 (((char *) (&hdr
))[i
]) = ' ';
1766 if ((bfd_write ((char *) &hdr
, 1, sizeof (struct ar_hdr
), arch
)
1767 != sizeof (struct ar_hdr
))
1768 || bfd_write (etable
, 1, elength
, arch
) != elength
)
1770 if ((elength
% 2) == 1)
1772 if (bfd_write ("\012", 1, 1, arch
) != 1)
1777 for (current
= arch
->archive_head
; current
; current
= current
->next
)
1779 char buffer
[DEFAULT_BUFFERSIZE
];
1780 unsigned int remaining
= arelt_size (current
);
1781 struct ar_hdr
*hdr
= arch_hdr (current
);
1783 /* Write ar header. */
1784 if (bfd_write ((char *) hdr
, 1, sizeof (*hdr
), arch
) != sizeof (*hdr
))
1786 if (bfd_seek (current
, (file_ptr
) 0, SEEK_SET
) != 0)
1790 unsigned int amt
= DEFAULT_BUFFERSIZE
;
1791 if (amt
> remaining
)
1794 if (bfd_read (buffer
, amt
, 1, current
) != amt
)
1796 if (bfd_get_error () != bfd_error_system_call
)
1797 bfd_set_error (bfd_error_malformed_archive
);
1800 if (bfd_write (buffer
, amt
, 1, arch
) != amt
)
1804 if ((arelt_size (current
) % 2) == 1)
1806 if (bfd_write ("\012", 1, 1, arch
) != 1)
1811 if (makemap
&& hasobjects
)
1813 /* Verify the timestamp in the archive file. If it would not be
1814 accepted by the linker, rewrite it until it would be. If
1815 anything odd happens, break out and just return. (The
1816 Berkeley linker checks the timestamp and refuses to read the
1817 table-of-contents if it is >60 seconds less than the file's
1818 modified-time. That painful hack requires this painful hack. */
1822 if (bfd_update_armap_timestamp (arch
))
1824 (*_bfd_error_handler
)
1825 (_("Warning: writing archive was slow: rewriting timestamp\n"));
1827 while (++tries
< 6);
1833 /* Note that the namidx for the first symbol is 0. */
1836 _bfd_compute_and_write_armap (arch
, elength
)
1838 unsigned int elength
;
1840 char *first_name
= NULL
;
1842 file_ptr elt_no
= 0;
1843 struct orl
*map
= NULL
;
1844 int orl_max
= 1024; /* fine initial default */
1846 int stridx
= 0; /* string index */
1847 asymbol
**syms
= NULL
;
1851 /* Dunno if this is the best place for this info... */
1853 elength
+= sizeof (struct ar_hdr
);
1854 elength
+= elength
% 2;
1856 map
= (struct orl
*) bfd_malloc (orl_max
* sizeof (struct orl
));
1860 /* We put the symbol names on the arch objalloc, and then discard
1862 first_name
= bfd_alloc (arch
, 1);
1863 if (first_name
== NULL
)
1866 /* Drop all the files called __.SYMDEF, we're going to make our own. */
1867 while (arch
->archive_head
&&
1868 strcmp (arch
->archive_head
->filename
, "__.SYMDEF") == 0)
1869 arch
->archive_head
= arch
->archive_head
->next
;
1871 /* Map over each element. */
1872 for (current
= arch
->archive_head
;
1873 current
!= (bfd
*) NULL
;
1874 current
= current
->next
, elt_no
++)
1876 if ((bfd_check_format (current
, bfd_object
) == true)
1877 && ((bfd_get_file_flags (current
) & HAS_SYMS
)))
1883 storage
= bfd_get_symtab_upper_bound (current
);
1889 if (storage
> syms_max
)
1894 syms
= (asymbol
**) bfd_malloc ((size_t) syms_max
);
1898 symcount
= bfd_canonicalize_symtab (current
, syms
);
1902 /* Now map over all the symbols, picking out the ones we
1904 for (src_count
= 0; src_count
< symcount
; src_count
++)
1906 flagword flags
= (syms
[src_count
])->flags
;
1907 asection
*sec
= syms
[src_count
]->section
;
1909 if ((flags
& BSF_GLOBAL
||
1911 flags
& BSF_INDIRECT
||
1912 bfd_is_com_section (sec
))
1913 && ! bfd_is_und_section (sec
))
1916 struct orl
*new_map
;
1918 /* This symbol will go into the archive header. */
1919 if (orl_count
== orl_max
)
1924 bfd_realloc (map
, orl_max
* sizeof (struct orl
)));
1925 if (new_map
== (struct orl
*) NULL
)
1931 namelen
= strlen (syms
[src_count
]->name
);
1932 map
[orl_count
].name
= ((char **)
1935 if (map
[orl_count
].name
== NULL
)
1937 *(map
[orl_count
].name
) = bfd_alloc (arch
, namelen
+ 1);
1938 if (*(map
[orl_count
].name
) == NULL
)
1940 strcpy (*(map
[orl_count
].name
), syms
[src_count
]->name
);
1941 (map
[orl_count
]).pos
= (file_ptr
) current
;
1942 (map
[orl_count
]).namidx
= stridx
;
1944 stridx
+= namelen
+ 1;
1950 /* Now ask the BFD to free up any cached information, so we
1951 don't fill all of memory with symbol tables. */
1952 if (! bfd_free_cached_info (current
))
1957 /* OK, now we have collected all the data, let's write them out. */
1958 ret
= BFD_SEND (arch
, write_armap
,
1959 (arch
, elength
, map
, orl_count
, stridx
));
1965 if (first_name
!= NULL
)
1966 bfd_release (arch
, first_name
);
1975 if (first_name
!= NULL
)
1976 bfd_release (arch
, first_name
);
1982 bsd_write_armap (arch
, elength
, map
, orl_count
, stridx
)
1984 unsigned int elength
;
1986 unsigned int orl_count
;
1989 int padit
= stridx
& 1;
1990 unsigned int ranlibsize
= orl_count
* BSD_SYMDEF_SIZE
;
1991 unsigned int stringsize
= stridx
+ padit
;
1992 /* Include 8 bytes to store ranlibsize and stringsize in output. */
1993 unsigned int mapsize
= ranlibsize
+ stringsize
+ 8;
1995 bfd
*current
= arch
->archive_head
;
1996 bfd
*last_elt
= current
; /* last element arch seen */
2000 struct stat statbuf
;
2003 firstreal
= mapsize
+ elength
+ sizeof (struct ar_hdr
) + SARMAG
;
2005 stat (arch
->filename
, &statbuf
);
2006 memset ((char *) (&hdr
), 0, sizeof (struct ar_hdr
));
2007 sprintf (hdr
.ar_name
, RANLIBMAG
);
2008 /* Remember the timestamp, to keep it holy. But fudge it a little. */
2009 bfd_ardata (arch
)->armap_timestamp
= statbuf
.st_mtime
+ ARMAP_TIME_OFFSET
;
2010 bfd_ardata (arch
)->armap_datepos
= (SARMAG
2011 + offsetof (struct ar_hdr
, ar_date
[0]));
2012 sprintf (hdr
.ar_date
, "%ld", bfd_ardata (arch
)->armap_timestamp
);
2013 sprintf (hdr
.ar_uid
, "%ld", (long) getuid ());
2014 sprintf (hdr
.ar_gid
, "%ld", (long) getgid ());
2015 sprintf (hdr
.ar_size
, "%-10d", (int) mapsize
);
2016 strncpy (hdr
.ar_fmag
, ARFMAG
, 2);
2017 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
2018 if (((char *) (&hdr
))[i
] == '\0')
2019 (((char *) (&hdr
))[i
]) = ' ';
2020 if (bfd_write ((char *) &hdr
, 1, sizeof (struct ar_hdr
), arch
)
2021 != sizeof (struct ar_hdr
))
2023 bfd_h_put_32 (arch
, (bfd_vma
) ranlibsize
, temp
);
2024 if (bfd_write (temp
, 1, sizeof (temp
), arch
) != sizeof (temp
))
2027 for (count
= 0; count
< orl_count
; count
++)
2029 bfd_byte buf
[BSD_SYMDEF_SIZE
];
2031 if (((bfd
*) (map
[count
]).pos
) != last_elt
)
2035 firstreal
+= arelt_size (current
) + sizeof (struct ar_hdr
);
2036 firstreal
+= firstreal
% 2;
2037 current
= current
->next
;
2039 while (current
!= (bfd
*) (map
[count
]).pos
);
2040 } /* if new archive element */
2043 bfd_h_put_32 (arch
, map
[count
].namidx
, buf
);
2044 bfd_h_put_32 (arch
, firstreal
, buf
+ BSD_SYMDEF_OFFSET_SIZE
);
2045 if (bfd_write (buf
, BSD_SYMDEF_SIZE
, 1, arch
) != BSD_SYMDEF_SIZE
)
2049 /* Now write the strings themselves. */
2050 bfd_h_put_32 (arch
, stringsize
, temp
);
2051 if (bfd_write (temp
, 1, sizeof (temp
), arch
) != sizeof (temp
))
2053 for (count
= 0; count
< orl_count
; count
++)
2055 size_t len
= strlen (*map
[count
].name
) + 1;
2057 if (bfd_write (*map
[count
].name
, 1, len
, arch
) != len
)
2061 /* The spec sez this should be a newline. But in order to be
2062 bug-compatible for sun's ar we use a null. */
2065 if (bfd_write ("", 1, 1, arch
) != 1)
2072 /* At the end of archive file handling, update the timestamp in the
2073 file, so the linker will accept it.
2075 Return true if the timestamp was OK, or an unusual problem happened.
2076 Return false if we updated the timestamp. */
2079 _bfd_archive_bsd_update_armap_timestamp (arch
)
2082 struct stat archstat
;
2086 /* Flush writes, get last-write timestamp from file, and compare it
2087 to the timestamp IN the file. */
2089 if (bfd_stat (arch
, &archstat
) == -1)
2091 perror (_("Reading archive file mod timestamp"));
2093 /* Can't read mod time for some reason. */
2096 if (archstat
.st_mtime
<= bfd_ardata (arch
)->armap_timestamp
)
2097 /* OK by the linker's rules. */
2100 /* Update the timestamp. */
2101 bfd_ardata (arch
)->armap_timestamp
= archstat
.st_mtime
+ ARMAP_TIME_OFFSET
;
2103 /* Prepare an ASCII version suitable for writing. */
2104 memset (hdr
.ar_date
, 0, sizeof (hdr
.ar_date
));
2105 sprintf (hdr
.ar_date
, "%ld", bfd_ardata (arch
)->armap_timestamp
);
2106 for (i
= 0; i
< sizeof (hdr
.ar_date
); i
++)
2107 if (hdr
.ar_date
[i
] == '\0')
2108 (hdr
.ar_date
)[i
] = ' ';
2110 /* Write it into the file. */
2111 bfd_ardata (arch
)->armap_datepos
= (SARMAG
2112 + offsetof (struct ar_hdr
, ar_date
[0]));
2113 if (bfd_seek (arch
, bfd_ardata (arch
)->armap_datepos
, SEEK_SET
) != 0
2114 || (bfd_write (hdr
.ar_date
, sizeof (hdr
.ar_date
), 1, arch
)
2115 != sizeof (hdr
.ar_date
)))
2117 /* FIXME: bfd can't call perror. */
2118 perror (_("Writing updated armap timestamp"));
2120 /* Some error while writing. */
2124 /* We updated the timestamp successfully. */
2128 /* A coff armap looks like :
2130 struct ar_hdr with name = '/'
2132 offset of file for symbol 0
2133 offset of file for symbol 1
2135 offset of file for symbol n-1
2143 coff_write_armap (arch
, elength
, map
, symbol_count
, stridx
)
2145 unsigned int elength
;
2147 unsigned int symbol_count
;
2150 /* The size of the ranlib is the number of exported symbols in the
2151 archive * the number of bytes in a int, + an int for the count. */
2152 unsigned int ranlibsize
= (symbol_count
* 4) + 4;
2153 unsigned int stringsize
= stridx
;
2154 unsigned int mapsize
= stringsize
+ ranlibsize
;
2155 file_ptr archive_member_file_ptr
;
2156 bfd
*current
= arch
->archive_head
;
2160 int padit
= mapsize
& 1;
2165 /* Work out where the first object file will go in the archive. */
2166 archive_member_file_ptr
= (mapsize
2168 + sizeof (struct ar_hdr
)
2171 memset ((char *) (&hdr
), 0, sizeof (struct ar_hdr
));
2172 hdr
.ar_name
[0] = '/';
2173 sprintf (hdr
.ar_size
, "%-10d", (int) mapsize
);
2174 sprintf (hdr
.ar_date
, "%ld", (long) time (NULL
));
2175 /* This, at least, is what Intel coff sets the values to. */
2176 sprintf ((hdr
.ar_uid
), "%d", 0);
2177 sprintf ((hdr
.ar_gid
), "%d", 0);
2178 sprintf ((hdr
.ar_mode
), "%-7o", (unsigned) 0);
2179 strncpy (hdr
.ar_fmag
, ARFMAG
, 2);
2181 for (i
= 0; i
< sizeof (struct ar_hdr
); i
++)
2182 if (((char *) (&hdr
))[i
] == '\0')
2183 (((char *) (&hdr
))[i
]) = ' ';
2185 /* Write the ar header for this item and the number of symbols. */
2187 if (bfd_write ((PTR
) &hdr
, 1, sizeof (struct ar_hdr
), arch
)
2188 != sizeof (struct ar_hdr
))
2191 bfd_write_bigendian_4byte_int (arch
, symbol_count
);
2193 /* Two passes, first write the file offsets for each symbol -
2194 remembering that each offset is on a two byte boundary. */
2196 /* Write out the file offset for the file associated with each
2197 symbol, and remember to keep the offsets padded out. */
2199 current
= arch
->archive_head
;
2201 while (current
!= (bfd
*) NULL
&& count
< symbol_count
)
2203 /* For each symbol which is used defined in this object, write
2204 out the object file's address in the archive. */
2206 while (count
< symbol_count
&& ((bfd
*) (map
[count
]).pos
) == current
)
2208 bfd_write_bigendian_4byte_int (arch
, archive_member_file_ptr
);
2211 /* Add size of this archive entry. */
2212 archive_member_file_ptr
+= (arelt_size (current
)
2213 + sizeof (struct ar_hdr
));
2214 /* Remember aboout the even alignment. */
2215 archive_member_file_ptr
+= archive_member_file_ptr
% 2;
2216 current
= current
->next
;
2219 /* Now write the strings themselves. */
2220 for (count
= 0; count
< symbol_count
; count
++)
2222 size_t len
= strlen (*map
[count
].name
) + 1;
2224 if (bfd_write (*map
[count
].name
, 1, len
, arch
) != len
)
2228 /* The spec sez this should be a newline. But in order to be
2229 bug-compatible for arc960 we use a null. */
2232 if (bfd_write ("", 1, 1, arch
) != 1)