1 /* BFD back-end for archive files (libraries).
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
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 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
24 @setfilename archive-info
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>>.
82 o - all archive elements start on an even boundary, newline padded;
83 o - all arch headers are char *;
84 o - all arch headers are the same size (across architectures).
87 /* Some formats provide a way to cram a long filename into the short
88 (16 chars) space provided by a BSD archive. The trick is: make a
89 special "file" in the front of the archive, sort of like the SYMDEF
90 entry. If the filename is too long to fit, put it in the extended
91 name table, and use its index as the filename. To prevent
92 confusion prepend the index with a space. This means you can't
93 have filenames that start with a space, but then again, many Unix
94 utilities can't handle that anyway.
96 This scheme unfortunately requires that you stand on your head in
97 order to write an archive since you need to put a magic file at the
98 front, and need to touch every entry to do so. C'est la vie.
100 We support two variants of this idea:
101 The SVR4 format (extended name table is named "//"),
102 and an extended pseudo-BSD variant (extended name table is named
103 "ARFILENAMES/"). The origin of the latter format is uncertain.
105 BSD 4.4 uses a third scheme: It writes a long filename
106 directly after the header. This allows 'ar q' to work.
109 /* Summary of archive member names:
111 Symbol table (must be first):
112 "__.SYMDEF " - Symbol table, Berkeley style, produced by ranlib.
113 "/ " - Symbol table, system 5 style.
115 Long name table (must be before regular file members):
116 "// " - Long name table, System 5 R4 style.
117 "ARFILENAMES/ " - Long name table, non-standard extended BSD (not BSD 4.4).
119 Regular file members with short names:
120 "filename.o/ " - Regular file, System 5 style (embedded spaces ok).
121 "filename.o " - Regular file, Berkeley style (no embedded spaces).
123 Regular files with long names (or embedded spaces, for BSD variants):
124 "/18 " - SVR4 style, name at offset 18 in name table.
125 "#1/23 " - Long name (or embedded spaces) 23 characters long,
126 BSD 4.4 style, full name follows header.
127 " 18 " - Long name 18 characters long, extended pseudo-BSD.
132 #include "libiberty.h"
135 #include "aout/ranlib.h"
136 #include "safe-ctype.h"
138 #include "filenames.h"
144 /* We keep a cache of archive filepointers to archive elements to
145 speed up searching the archive by filepos. We only add an entry to
146 the cache when we actually read one. We also don't sort the cache;
147 it's generally short enough to search linearly.
148 Note that the pointers here point to the front of the ar_hdr, not
149 to the front of the contents! */
155 #define ar_padchar(abfd) ((abfd)->xvec->ar_pad_char)
156 #define ar_maxnamelen(abfd) ((abfd)->xvec->ar_max_namelen)
158 #define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data))
159 #define arch_hdr(bfd) ((struct ar_hdr *) arch_eltdata (bfd)->arch_header)
161 /* True iff NAME designated a BSD 4.4 extended name. */
163 #define is_bsd44_extended_name(NAME) \
164 (NAME[0] == '#' && NAME[1] == '1' && NAME[2] == '/' && ISDIGIT (NAME[3]))
167 _bfd_ar_spacepad (char *p, size_t n, const char *fmt, long val)
171 snprintf (buf, sizeof (buf), fmt, val);
175 memcpy (p, buf, len);
176 memset (p + len, ' ', n - len);
183 _bfd_generic_mkarchive (bfd *abfd)
185 bfd_size_type amt = sizeof (struct artdata);
187 abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc (abfd, amt);
188 if (bfd_ardata (abfd) == NULL)
191 /* Already cleared by bfd_zalloc above.
192 bfd_ardata (abfd)->cache = NULL;
193 bfd_ardata (abfd)->archive_head = NULL;
194 bfd_ardata (abfd)->symdefs = NULL;
195 bfd_ardata (abfd)->extended_names = NULL;
196 bfd_ardata (abfd)->extended_names_size = 0;
197 bfd_ardata (abfd)->tdata = NULL; */
207 symindex bfd_get_next_mapent
208 (bfd *abfd, symindex previous, carsym **sym);
211 Step through archive @var{abfd}'s symbol table (if it
212 has one). Successively update @var{sym} with the next symbol's
213 information, returning that symbol's (internal) index into the
216 Supply <<BFD_NO_MORE_SYMBOLS>> as the @var{previous} entry to get
217 the first one; returns <<BFD_NO_MORE_SYMBOLS>> when you've already
220 A <<carsym>> is a canonical archive symbol. The only
221 user-visible element is its name, a null-terminated string.
225 bfd_get_next_mapent (bfd *abfd, symindex prev, carsym **entry)
227 if (!bfd_has_map (abfd))
229 bfd_set_error (bfd_error_invalid_operation);
230 return BFD_NO_MORE_SYMBOLS;
233 if (prev == BFD_NO_MORE_SYMBOLS)
237 if (prev >= bfd_ardata (abfd)->symdef_count)
238 return BFD_NO_MORE_SYMBOLS;
240 *entry = (bfd_ardata (abfd)->symdefs + prev);
244 /* To be called by backends only. */
247 _bfd_create_empty_archive_element_shell (bfd *obfd)
249 return _bfd_new_bfd_contained_in (obfd);
257 bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);
260 Set the head of the chain of
261 BFDs contained in the archive @var{output} to @var{new_head}.
265 bfd_set_archive_head (bfd *output_archive, bfd *new_head)
267 output_archive->archive_head = new_head;
272 _bfd_look_for_bfd_in_cache (bfd *arch_bfd, file_ptr filepos)
274 htab_t hash_table = bfd_ardata (arch_bfd)->cache;
280 struct ar_cache *entry = (struct ar_cache *) htab_find (hash_table, &m);
291 hash_file_ptr (const PTR p)
293 return (hashval_t) (((struct ar_cache *) p)->ptr);
296 /* Returns non-zero if P1 and P2 are equal. */
299 eq_file_ptr (const PTR p1, const PTR p2)
301 struct ar_cache *arc1 = (struct ar_cache *) p1;
302 struct ar_cache *arc2 = (struct ar_cache *) p2;
303 return arc1->ptr == arc2->ptr;
306 /* The calloc function doesn't always take size_t (e.g. on VMS)
307 so wrap it to avoid a compile time warning. */
310 _bfd_calloc_wrapper (size_t a, size_t b)
312 return calloc (a, b);
315 /* Kind of stupid to call cons for each one, but we don't do too many. */
318 _bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt)
320 struct ar_cache *cache;
321 htab_t hash_table = bfd_ardata (arch_bfd)->cache;
323 /* If the hash table hasn't been created, create it. */
324 if (hash_table == NULL)
326 hash_table = htab_create_alloc (16, hash_file_ptr, eq_file_ptr,
327 NULL, _bfd_calloc_wrapper, free);
328 if (hash_table == NULL)
330 bfd_ardata (arch_bfd)->cache = hash_table;
333 /* Insert new_elt into the hash table by filepos. */
334 cache = (struct ar_cache *) bfd_zalloc (arch_bfd, sizeof (struct ar_cache));
335 cache->ptr = filepos;
336 cache->arbfd = new_elt;
337 *htab_find_slot (hash_table, (const void *) cache, INSERT) = cache;
343 _bfd_find_nested_archive (bfd *arch_bfd, const char *filename)
347 for (abfd = arch_bfd->nested_archives;
349 abfd = abfd->archive_next)
351 if (filename_cmp (filename, abfd->filename) == 0)
354 abfd = bfd_openr (filename, NULL);
357 abfd->archive_next = arch_bfd->nested_archives;
358 arch_bfd->nested_archives = abfd;
363 /* The name begins with space. Hence the rest of the name is an index into
367 get_extended_arelt_filename (bfd *arch, const char *name, file_ptr *originp)
369 unsigned long table_index = 0;
372 /* Should extract string so that I can guarantee not to overflow into
373 the next region, but I'm too lazy. */
375 /* Skip first char, which is '/' in SVR4 or ' ' in some other variants. */
376 table_index = strtol (name + 1, (char **) &endp, 10);
377 if (errno != 0 || table_index >= bfd_ardata (arch)->extended_names_size)
379 bfd_set_error (bfd_error_malformed_archive);
382 /* In a thin archive, a member of an archive-within-an-archive
383 will have the offset in the inner archive encoded here. */
384 if (bfd_is_thin_archive (arch) && endp != NULL && *endp == ':')
386 file_ptr origin = strtol (endp + 1, NULL, 10);
390 bfd_set_error (bfd_error_malformed_archive);
398 return bfd_ardata (arch)->extended_names + table_index;
401 /* This functions reads an arch header and returns an areltdata pointer, or
404 Presumes the file pointer is already in the right place (ie pointing
405 to the ar_hdr in the file). Moves the file pointer; on success it
406 should be pointing to the front of the file contents; on failure it
407 could have been moved arbitrarily. */
410 _bfd_generic_read_ar_hdr (bfd *abfd)
412 return _bfd_generic_read_ar_hdr_mag (abfd, NULL);
415 /* Alpha ECOFF uses an optional different ARFMAG value, so we have a
416 variant of _bfd_generic_read_ar_hdr which accepts a magic string. */
419 _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
422 char *hdrp = (char *) &hdr;
424 struct areltdata *ared;
425 char *filename = NULL;
426 bfd_size_type namelen = 0;
427 bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
430 unsigned int extra_size = 0;
432 if (bfd_bread (hdrp, sizeof (struct ar_hdr), abfd) != sizeof (struct ar_hdr))
434 if (bfd_get_error () != bfd_error_system_call)
435 bfd_set_error (bfd_error_no_more_archived_files);
438 if (strncmp (hdr.ar_fmag, ARFMAG, 2) != 0
440 || strncmp (hdr.ar_fmag, mag, 2) != 0))
442 bfd_set_error (bfd_error_malformed_archive);
447 parsed_size = strtol (hdr.ar_size, NULL, 10);
450 bfd_set_error (bfd_error_malformed_archive);
454 /* Extract the filename from the archive - there are two ways to
455 specify an extended name table, either the first char of the
456 name is a space, or it's a slash. */
457 if ((hdr.ar_name[0] == '/'
458 || (hdr.ar_name[0] == ' '
459 && memchr (hdr.ar_name, '/', ar_maxnamelen (abfd)) == NULL))
460 && bfd_ardata (abfd)->extended_names != NULL)
462 filename = get_extended_arelt_filename (abfd, hdr.ar_name, &origin);
463 if (filename == NULL)
466 /* BSD4.4-style long filename. */
467 else if (is_bsd44_extended_name (hdr.ar_name))
469 /* BSD-4.4 extended name */
470 namelen = atoi (&hdr.ar_name[3]);
471 allocsize += namelen + 1;
472 parsed_size -= namelen;
473 extra_size = namelen;
475 allocptr = (char *) bfd_zalloc (abfd, allocsize);
476 if (allocptr == NULL)
479 + sizeof (struct areltdata)
480 + sizeof (struct ar_hdr));
481 if (bfd_bread (filename, namelen, abfd) != namelen)
483 if (bfd_get_error () != bfd_error_system_call)
484 bfd_set_error (bfd_error_no_more_archived_files);
487 filename[namelen] = '\0';
491 /* We judge the end of the name by looking for '/' or ' '.
492 Note: The SYSV format (terminated by '/') allows embedded
493 spaces, so only look for ' ' if we don't find '/'. */
496 e = (char *) memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
499 e = (char *) memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
501 e = (char *) memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
505 namelen = e - hdr.ar_name;
508 /* If we didn't find a termination character, then the name
509 must be the entire field. */
510 namelen = ar_maxnamelen (abfd);
513 allocsize += namelen + 1;
518 allocptr = (char *) bfd_zalloc (abfd, allocsize);
519 if (allocptr == NULL)
523 ared = (struct areltdata *) allocptr;
525 ared->arch_header = allocptr + sizeof (struct areltdata);
526 memcpy (ared->arch_header, &hdr, sizeof (struct ar_hdr));
527 ared->parsed_size = parsed_size;
528 ared->extra_size = extra_size;
529 ared->origin = origin;
531 if (filename != NULL)
532 ared->filename = filename;
535 ared->filename = allocptr + (sizeof (struct areltdata) +
536 sizeof (struct ar_hdr));
538 memcpy (ared->filename, hdr.ar_name, namelen);
539 ared->filename[namelen] = '\0';
545 /* Append the relative pathname for a member of the thin archive
546 to the pathname of the directory containing the archive. */
549 _bfd_append_relative_path (bfd *arch, char *elt_name)
551 const char *arch_name = arch->filename;
552 const char *base_name = lbasename (arch_name);
556 if (base_name == arch_name)
559 prefix_len = base_name - arch_name;
560 filename = (char *) bfd_alloc (arch, prefix_len + strlen (elt_name) + 1);
561 if (filename == NULL)
564 strncpy (filename, arch_name, prefix_len);
565 strcpy (filename + prefix_len, elt_name);
569 /* This is an internal function; it's mainly used when indexing
570 through the archive symbol table, but also used to get the next
571 element, since it handles the bookkeeping so nicely for us. */
574 _bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos)
576 struct areltdata *new_areldata;
580 if (archive->my_archive)
582 filepos += archive->origin;
583 archive = archive->my_archive;
586 n_nfd = _bfd_look_for_bfd_in_cache (archive, filepos);
590 if (0 > bfd_seek (archive, filepos, SEEK_SET))
593 if ((new_areldata = (struct areltdata *) _bfd_read_ar_hdr (archive)) == NULL)
596 filename = new_areldata->filename;
598 if (bfd_is_thin_archive (archive))
600 /* This is a proxy entry for an external file. */
601 if (! IS_ABSOLUTE_PATH (filename))
603 filename = _bfd_append_relative_path (archive, filename);
604 if (filename == NULL)
608 if (new_areldata->origin > 0)
610 /* This proxy entry refers to an element of a nested archive.
611 Locate the member of that archive and return a bfd for it. */
612 bfd *ext_arch = _bfd_find_nested_archive (archive, filename);
615 || ! bfd_check_format (ext_arch, bfd_archive))
617 bfd_release (archive, new_areldata);
620 n_nfd = _bfd_get_elt_at_filepos (ext_arch, new_areldata->origin);
623 bfd_release (archive, new_areldata);
626 n_nfd->proxy_origin = bfd_tell (archive);
629 /* It's not an element of a nested archive;
630 open the external file as a bfd. */
631 n_nfd = bfd_openr (filename, NULL);
633 bfd_set_error (bfd_error_malformed_archive);
637 n_nfd = _bfd_create_empty_archive_element_shell (archive);
642 bfd_release (archive, new_areldata);
646 n_nfd->proxy_origin = bfd_tell (archive);
648 if (bfd_is_thin_archive (archive))
654 n_nfd->origin = n_nfd->proxy_origin;
655 n_nfd->filename = filename;
658 n_nfd->arelt_data = new_areldata;
660 /* Copy BFD_COMPRESS and BFD_DECOMPRESS flags. */
661 n_nfd->flags |= archive->flags & (BFD_COMPRESS | BFD_DECOMPRESS);
663 if (_bfd_add_bfd_to_archive_cache (archive, filepos, n_nfd))
666 bfd_release (archive, new_areldata);
670 /* Return the BFD which is referenced by the symbol in ABFD indexed by
671 SYM_INDEX. SYM_INDEX should have been returned by bfd_get_next_mapent. */
674 _bfd_generic_get_elt_at_index (bfd *abfd, symindex sym_index)
678 entry = bfd_ardata (abfd)->symdefs + sym_index;
679 return _bfd_get_elt_at_filepos (abfd, entry->file_offset);
684 bfd_openr_next_archived_file
687 bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous);
690 Provided a BFD, @var{archive}, containing an archive and NULL, open
691 an input BFD on the first contained element and returns that.
692 Subsequent calls should pass
693 the archive and the previous return value to return a created
694 BFD to the next contained element. NULL is returned when there
699 bfd_openr_next_archived_file (bfd *archive, bfd *last_file)
701 if ((bfd_get_format (archive) != bfd_archive)
702 || (archive->direction == write_direction))
704 bfd_set_error (bfd_error_invalid_operation);
708 return BFD_SEND (archive,
709 openr_next_archived_file, (archive, last_file));
713 bfd_generic_openr_next_archived_file (bfd *archive, bfd *last_file)
718 filestart = bfd_ardata (archive)->first_file_filepos;
721 unsigned int size = arelt_size (last_file);
723 filestart = last_file->proxy_origin;
724 if (! bfd_is_thin_archive (archive))
726 if (archive->my_archive)
727 filestart -= archive->origin;
728 /* Pad to an even boundary...
729 Note that last_file->origin can be odd in the case of
730 BSD-4.4-style element with a long odd size. */
731 filestart += filestart % 2;
734 return _bfd_get_elt_at_filepos (archive, filestart);
738 bfd_generic_archive_p (bfd *abfd)
740 struct artdata *tdata_hold;
741 char armag[SARMAG + 1];
744 if (bfd_bread (armag, SARMAG, abfd) != SARMAG)
746 if (bfd_get_error () != bfd_error_system_call)
747 bfd_set_error (bfd_error_wrong_format);
751 bfd_is_thin_archive (abfd) = (strncmp (armag, ARMAGT, SARMAG) == 0);
753 if (strncmp (armag, ARMAG, SARMAG) != 0
754 && strncmp (armag, ARMAGB, SARMAG) != 0
755 && ! bfd_is_thin_archive (abfd))
758 tdata_hold = bfd_ardata (abfd);
760 amt = sizeof (struct artdata);
761 bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
762 if (bfd_ardata (abfd) == NULL)
764 bfd_ardata (abfd) = tdata_hold;
768 bfd_ardata (abfd)->first_file_filepos = SARMAG;
769 /* Cleared by bfd_zalloc above.
770 bfd_ardata (abfd)->cache = NULL;
771 bfd_ardata (abfd)->archive_head = NULL;
772 bfd_ardata (abfd)->symdefs = NULL;
773 bfd_ardata (abfd)->extended_names = NULL;
774 bfd_ardata (abfd)->extended_names_size = 0;
775 bfd_ardata (abfd)->tdata = NULL; */
777 if (!BFD_SEND (abfd, _bfd_slurp_armap, (abfd))
778 || !BFD_SEND (abfd, _bfd_slurp_extended_name_table, (abfd)))
780 if (bfd_get_error () != bfd_error_system_call)
781 bfd_set_error (bfd_error_wrong_format);
782 bfd_release (abfd, bfd_ardata (abfd));
783 bfd_ardata (abfd) = tdata_hold;
787 if (bfd_has_map (abfd))
791 /* This archive has a map, so we may presume that the contents
792 are object files. Make sure that if the first file in the
793 archive can be recognized as an object file, it is for this
794 target. If not, assume that this is the wrong format. If
795 the first file is not an object file, somebody is doing
796 something weird, and we permit it so that ar -t will work.
798 This is done because any normal format will recognize any
799 normal archive, regardless of the format of the object files.
800 We do accept an empty archive. */
802 first = bfd_openr_next_archived_file (abfd, NULL);
805 first->target_defaulted = FALSE;
806 if (bfd_check_format (first, bfd_object)
807 && first->xvec != abfd->xvec)
809 bfd_set_error (bfd_error_wrong_object_format);
810 bfd_ardata (abfd) = tdata_hold;
813 /* And we ought to close `first' here too. */
820 /* Some constants for a 32 bit BSD archive structure. We do not
821 support 64 bit archives presently; so far as I know, none actually
822 exist. Supporting them would require changing these constants, and
823 changing some H_GET_32 to H_GET_64. */
825 /* The size of an external symdef structure. */
826 #define BSD_SYMDEF_SIZE 8
828 /* The offset from the start of a symdef structure to the file offset. */
829 #define BSD_SYMDEF_OFFSET_SIZE 4
831 /* The size of the symdef count. */
832 #define BSD_SYMDEF_COUNT_SIZE 4
834 /* The size of the string count. */
835 #define BSD_STRING_COUNT_SIZE 4
837 /* Read a BSD-style archive symbol table. Returns FALSE on error,
841 do_slurp_bsd_armap (bfd *abfd)
843 struct areltdata *mapdata;
844 unsigned int counter;
845 bfd_byte *raw_armap, *rbase;
846 struct artdata *ardata = bfd_ardata (abfd);
848 bfd_size_type parsed_size, amt;
851 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
854 parsed_size = mapdata->parsed_size;
855 bfd_release (abfd, mapdata); /* Don't need it any more. */
857 raw_armap = (bfd_byte *) bfd_zalloc (abfd, parsed_size);
858 if (raw_armap == NULL)
861 if (bfd_bread (raw_armap, parsed_size, abfd) != parsed_size)
863 if (bfd_get_error () != bfd_error_system_call)
864 bfd_set_error (bfd_error_malformed_archive);
866 bfd_release (abfd, raw_armap);
870 ardata->symdef_count = H_GET_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE;
872 if (ardata->symdef_count * BSD_SYMDEF_SIZE >
873 parsed_size - BSD_SYMDEF_COUNT_SIZE)
875 /* Probably we're using the wrong byte ordering. */
876 bfd_set_error (bfd_error_wrong_format);
881 rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE;
882 stringbase = ((char *) rbase
883 + ardata->symdef_count * BSD_SYMDEF_SIZE
884 + BSD_STRING_COUNT_SIZE);
885 amt = ardata->symdef_count * sizeof (carsym);
886 ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt);
887 if (!ardata->symdefs)
890 for (counter = 0, set = ardata->symdefs;
891 counter < ardata->symdef_count;
892 counter++, set++, rbase += BSD_SYMDEF_SIZE)
894 set->name = H_GET_32 (abfd, rbase) + stringbase;
895 set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
898 ardata->first_file_filepos = bfd_tell (abfd);
899 /* Pad to an even boundary if you have to. */
900 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
901 /* FIXME, we should provide some way to free raw_ardata when
902 we are done using the strings from it. For now, it seems
903 to be allocated on an objalloc anyway... */
904 bfd_has_map (abfd) = TRUE;
908 /* Read a COFF archive symbol table. Returns FALSE on error, TRUE
912 do_slurp_coff_armap (bfd *abfd)
914 struct areltdata *mapdata;
915 int *raw_armap, *rawptr;
916 struct artdata *ardata = bfd_ardata (abfd);
918 bfd_size_type stringsize;
919 unsigned int parsed_size;
921 bfd_size_type nsymz; /* Number of symbols in armap. */
922 bfd_vma (*swap) (const void *);
923 char int_buf[sizeof (long)];
924 bfd_size_type carsym_size, ptrsize;
927 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
930 parsed_size = mapdata->parsed_size;
931 bfd_release (abfd, mapdata); /* Don't need it any more. */
933 if (bfd_bread (int_buf, 4, abfd) != 4)
935 if (bfd_get_error () != bfd_error_system_call)
936 bfd_set_error (bfd_error_malformed_archive);
939 /* It seems that all numeric information in a coff archive is always
940 in big endian format, nomatter the host or target. */
942 nsymz = bfd_getb32 (int_buf);
943 stringsize = parsed_size - (4 * nsymz) - 4;
945 /* ... except that some archive formats are broken, and it may be our
946 fault - the i960 little endian coff sometimes has big and sometimes
947 little, because our tools changed. Here's a horrible hack to clean
950 if (stringsize > 0xfffff
951 && bfd_get_arch (abfd) == bfd_arch_i960
952 && bfd_get_flavour (abfd) == bfd_target_coff_flavour)
954 /* This looks dangerous, let's do it the other way around. */
955 nsymz = bfd_getl32 (int_buf);
956 stringsize = parsed_size - (4 * nsymz) - 4;
960 /* The coff armap must be read sequentially. So we construct a
961 bsd-style one in core all at once, for simplicity. */
963 if (nsymz > ~ (bfd_size_type) 0 / sizeof (carsym))
966 carsym_size = (nsymz * sizeof (carsym));
967 ptrsize = (4 * nsymz);
969 if (carsym_size + stringsize + 1 <= carsym_size)
972 ardata->symdefs = (struct carsym *) bfd_zalloc (abfd,
973 carsym_size + stringsize + 1);
974 if (ardata->symdefs == NULL)
976 carsyms = ardata->symdefs;
977 stringbase = ((char *) ardata->symdefs) + carsym_size;
979 /* Allocate and read in the raw offsets. */
980 raw_armap = (int *) bfd_alloc (abfd, ptrsize);
981 if (raw_armap == NULL)
982 goto release_symdefs;
983 if (bfd_bread (raw_armap, ptrsize, abfd) != ptrsize
984 || (bfd_bread (stringbase, stringsize, abfd) != stringsize))
986 if (bfd_get_error () != bfd_error_system_call)
987 bfd_set_error (bfd_error_malformed_archive);
988 goto release_raw_armap;
991 /* OK, build the carsyms. */
992 for (i = 0; i < nsymz; i++)
994 rawptr = raw_armap + i;
995 carsyms->file_offset = swap ((bfd_byte *) rawptr);
996 carsyms->name = stringbase;
997 stringbase += strlen (stringbase) + 1;
1002 ardata->symdef_count = nsymz;
1003 ardata->first_file_filepos = bfd_tell (abfd);
1004 /* Pad to an even boundary if you have to. */
1005 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1007 bfd_has_map (abfd) = TRUE;
1008 bfd_release (abfd, raw_armap);
1010 /* Check for a second archive header (as used by PE). */
1012 struct areltdata *tmp;
1014 bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET);
1015 tmp = (struct areltdata *) _bfd_read_ar_hdr (abfd);
1018 if (tmp->arch_header[0] == '/'
1019 && tmp->arch_header[1] == ' ')
1021 ardata->first_file_filepos +=
1022 (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1;
1024 bfd_release (abfd, tmp);
1031 bfd_release (abfd, raw_armap);
1033 bfd_release (abfd, (ardata)->symdefs);
1037 /* This routine can handle either coff-style or bsd-style armaps
1038 (archive symbol table). Returns FALSE on error, TRUE otherwise */
1041 bfd_slurp_armap (bfd *abfd)
1044 int i = bfd_bread (nextname, 16, abfd);
1051 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1054 if (CONST_STRNEQ (nextname, "__.SYMDEF ")
1055 || CONST_STRNEQ (nextname, "__.SYMDEF/ ")) /* Old Linux archives. */
1056 return do_slurp_bsd_armap (abfd);
1057 else if (CONST_STRNEQ (nextname, "/ "))
1058 return do_slurp_coff_armap (abfd);
1059 else if (CONST_STRNEQ (nextname, "/SYM64/ "))
1061 /* 64bit ELF (Irix 6) archive. */
1063 extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *);
1064 return bfd_elf64_archive_slurp_armap (abfd);
1066 bfd_set_error (bfd_error_wrong_format);
1070 else if (CONST_STRNEQ (nextname, "#1/20 "))
1072 /* Mach-O has a special name for armap when the map is sorted by name.
1073 However because this name has a space it is slightly more difficult
1078 if (bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
1080 /* Read the extended name. We know its length. */
1081 if (bfd_bread (extname, 20, abfd) != 20)
1083 if (bfd_seek (abfd, (file_ptr) -(sizeof (hdr) + 20), SEEK_CUR) != 0)
1085 if (CONST_STRNEQ (extname, "__.SYMDEF SORTED")
1086 || CONST_STRNEQ (extname, "__.SYMDEF"))
1087 return do_slurp_bsd_armap (abfd);
1090 bfd_has_map (abfd) = FALSE;
1094 /* Returns FALSE on error, TRUE otherwise. */
1095 /* Flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
1096 header is in a slightly different order and the map name is '/'.
1097 This flavour is used by hp300hpux. */
1099 #define HPUX_SYMDEF_COUNT_SIZE 2
1102 bfd_slurp_bsd_armap_f2 (bfd *abfd)
1104 struct areltdata *mapdata;
1106 unsigned int counter;
1107 bfd_byte *raw_armap, *rbase;
1108 struct artdata *ardata = bfd_ardata (abfd);
1110 unsigned int stringsize;
1114 int i = bfd_bread (nextname, 16, abfd);
1121 /* The archive has at least 16 bytes in it. */
1122 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1125 if (CONST_STRNEQ (nextname, "__.SYMDEF ")
1126 || CONST_STRNEQ (nextname, "__.SYMDEF/ ")) /* Old Linux archives. */
1127 return do_slurp_bsd_armap (abfd);
1129 if (! CONST_STRNEQ (nextname, "/ "))
1131 bfd_has_map (abfd) = FALSE;
1135 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
1136 if (mapdata == NULL)
1139 if (mapdata->parsed_size < HPUX_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE)
1142 bfd_set_error (bfd_error_wrong_format);
1144 bfd_release (abfd, mapdata);
1147 left = mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE - BSD_STRING_COUNT_SIZE;
1149 amt = mapdata->parsed_size;
1150 raw_armap = (bfd_byte *) bfd_zalloc (abfd, amt);
1151 if (raw_armap == NULL)
1154 if (bfd_bread (raw_armap, amt, abfd) != amt)
1156 if (bfd_get_error () != bfd_error_system_call)
1157 bfd_set_error (bfd_error_malformed_archive);
1161 ardata->symdef_count = H_GET_16 (abfd, raw_armap);
1165 stringsize = H_GET_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE);
1166 if (stringsize > left)
1170 /* Skip sym count and string sz. */
1171 stringbase = ((char *) raw_armap
1172 + HPUX_SYMDEF_COUNT_SIZE
1173 + BSD_STRING_COUNT_SIZE);
1174 rbase = (bfd_byte *) stringbase + stringsize;
1175 amt = ardata->symdef_count * BSD_SYMDEF_SIZE;
1179 ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt);
1180 if (!ardata->symdefs)
1183 for (counter = 0, set = ardata->symdefs;
1184 counter < ardata->symdef_count;
1185 counter++, set++, rbase += BSD_SYMDEF_SIZE)
1187 set->name = H_GET_32 (abfd, rbase) + stringbase;
1188 set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
1191 ardata->first_file_filepos = bfd_tell (abfd);
1192 /* Pad to an even boundary if you have to. */
1193 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1194 /* FIXME, we should provide some way to free raw_ardata when
1195 we are done using the strings from it. For now, it seems
1196 to be allocated on an objalloc anyway... */
1197 bfd_has_map (abfd) = TRUE;
1201 /** Extended name table.
1203 Normally archives support only 14-character filenames.
1205 Intel has extended the format: longer names are stored in a special
1206 element (the first in the archive, or second if there is an armap);
1207 the name in the ar_hdr is replaced by <space><index into filename
1208 element>. Index is the P.R. of an int (decimal). Data General have
1209 extended the format by using the prefix // for the special element. */
1211 /* Returns FALSE on error, TRUE otherwise. */
1214 _bfd_slurp_extended_name_table (bfd *abfd)
1217 struct areltdata *namedata;
1220 /* FIXME: Formatting sucks here, and in case of failure of BFD_READ,
1221 we probably don't want to return TRUE. */
1222 if (bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET) != 0)
1225 if (bfd_bread (nextname, 16, abfd) == 16)
1227 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1230 if (! CONST_STRNEQ (nextname, "ARFILENAMES/ ")
1231 && ! CONST_STRNEQ (nextname, "// "))
1233 bfd_ardata (abfd)->extended_names = NULL;
1234 bfd_ardata (abfd)->extended_names_size = 0;
1238 namedata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
1239 if (namedata == NULL)
1242 amt = namedata->parsed_size;
1246 bfd_ardata (abfd)->extended_names_size = amt;
1247 bfd_ardata (abfd)->extended_names = (char *) bfd_zalloc (abfd, amt + 1);
1248 if (bfd_ardata (abfd)->extended_names == NULL)
1251 bfd_release (abfd, namedata);
1255 if (bfd_bread (bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
1257 if (bfd_get_error () != bfd_error_system_call)
1258 bfd_set_error (bfd_error_malformed_archive);
1259 bfd_release (abfd, (bfd_ardata (abfd)->extended_names));
1260 bfd_ardata (abfd)->extended_names = NULL;
1264 /* Since the archive is supposed to be printable if it contains
1265 text, the entries in the list are newline-padded, not null
1266 padded. In SVR4-style archives, the names also have a
1267 trailing '/'. DOS/NT created archive often have \ in them
1268 We'll fix all problems here.. */
1270 char *ext_names = bfd_ardata (abfd)->extended_names;
1271 char *temp = ext_names;
1272 char *limit = temp + namedata->parsed_size;
1273 for (; temp < limit; ++temp)
1275 if (*temp == ARFMAG[1])
1276 temp[temp > ext_names && temp[-1] == '/' ? -1 : 0] = '\0';
1283 /* Pad to an even boundary if you have to. */
1284 bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd);
1285 bfd_ardata (abfd)->first_file_filepos +=
1286 (bfd_ardata (abfd)->first_file_filepos) % 2;
1288 /* FIXME, we can't release namedata here because it was allocated
1289 below extended_names on the objalloc... */
1296 /* Return a copy of the stuff in the filename between any :]> and a
1300 normalize (bfd *abfd, const char *file)
1306 first = file + strlen (file) - 1;
1309 while (first != file)
1313 if (*first == ':' || *first == ']' || *first == '>')
1321 copy = bfd_alloc (abfd, last - first + 1);
1325 memcpy (copy, first, last - first);
1326 copy[last - first] = 0;
1333 normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file)
1335 return lbasename (file);
1339 /* Adjust a relative path name based on the reference path.
1342 Relative path Reference path Result
1343 ------------- -------------- ------
1345 foo/bar.o lib.a foo/bar.o
1346 bar.o foo/lib.a ../bar.o
1347 foo/bar.o baz/lib.a ../foo/bar.o
1348 bar.o ../lib.a <parent of current dir>/bar.o
1349 ../bar.o ../lib.a bar.o
1350 ../bar.o lib.a ../bar.o
1351 foo/bar.o ../lib.a <parent of current dir>/foo/bar.o
1352 bar.o ../../lib.a <grandparent>/<parent>/bar.o
1353 bar.o foo/baz/lib.a ../../bar.o
1355 Note - the returned string is in a static buffer. */
1358 adjust_relative_path (const char * path, const char * ref_path)
1360 static char *pathbuf = NULL;
1361 static unsigned int pathbuf_len = 0;
1367 unsigned int dir_up = 0;
1368 unsigned int dir_down = 0;
1370 char * pwd = getpwd ();
1373 /* Remove symlinks, '.' and '..' from the paths, if possible. */
1374 lpath = lrealpath (path);
1375 pathp = lpath == NULL ? path : lpath;
1377 rpath = lrealpath (ref_path);
1378 refp = rpath == NULL ? ref_path : rpath;
1380 /* Remove common leading path elements. */
1383 const char *e1 = pathp;
1384 const char *e2 = refp;
1386 while (*e1 && ! IS_DIR_SEPARATOR (*e1))
1388 while (*e2 && ! IS_DIR_SEPARATOR (*e2))
1390 if (*e1 == '\0' || *e2 == '\0' || e1 - pathp != e2 - refp
1391 || filename_ncmp (pathp, refp, e1 - pathp) != 0)
1397 len = strlen (pathp) + 1;
1398 /* For each leading path element in the reference path,
1399 insert "../" into the path. */
1400 for (; *refp; ++refp)
1401 if (IS_DIR_SEPARATOR (*refp))
1403 /* PR 12710: If the path element is "../" then instead of
1404 inserting "../" we need to insert the name of the directory
1405 at the current level. */
1406 if (refp > ref_path + 1
1414 /* If the lrealpath calls above succeeded then we should never
1415 see dir_up and dir_down both being non-zero. */
1421 down = pwd + strlen (pwd) - 1;
1423 while (dir_down && down > pwd)
1425 if (IS_DIR_SEPARATOR (*down))
1428 BFD_ASSERT (dir_down == 0);
1429 len += strlen (down) + 1;
1434 if (len > pathbuf_len)
1436 if (pathbuf != NULL)
1439 pathbuf = (char *) bfd_malloc (len);
1440 if (pathbuf == NULL)
1446 while (dir_up-- > 0)
1448 /* FIXME: Support Windows style path separators as well. */
1449 strcpy (newp, "../");
1454 sprintf (newp, "%s/%s", down, pathp);
1456 strcpy (newp, pathp);
1464 /* Build a BFD style extended name table. */
1467 _bfd_archive_bsd_construct_extended_name_table (bfd *abfd,
1469 bfd_size_type *tablen,
1472 *name = "ARFILENAMES/";
1473 return _bfd_construct_extended_name_table (abfd, FALSE, tabloc, tablen);
1476 /* Build an SVR4 style extended name table. */
1479 _bfd_archive_coff_construct_extended_name_table (bfd *abfd,
1481 bfd_size_type *tablen,
1485 return _bfd_construct_extended_name_table (abfd, TRUE, tabloc, tablen);
1488 /* Follows archive_head and produces an extended name table if
1489 necessary. Returns (in tabloc) a pointer to an extended name
1490 table, and in tablen the length of the table. If it makes an entry
1491 it clobbers the filename so that the element may be written without
1492 further massage. Returns TRUE if it ran successfully, FALSE if
1493 something went wrong. A successful return may still involve a
1494 zero-length tablen! */
1497 _bfd_construct_extended_name_table (bfd *abfd,
1498 bfd_boolean trailing_slash,
1500 bfd_size_type *tablen)
1502 unsigned int maxname = abfd->xvec->ar_max_namelen;
1503 bfd_size_type total_namelen = 0;
1506 const char *last_filename;
1510 last_filename = NULL;
1512 /* Figure out how long the table should be. */
1513 for (current = abfd->archive_head;
1515 current = current->archive_next)
1518 unsigned int thislen;
1520 if (bfd_is_thin_archive (abfd))
1522 const char *filename = current->filename;
1524 /* If the element being added is a member of another archive
1525 (i.e., we are flattening), use the containing archive's name. */
1526 if (current->my_archive
1527 && ! bfd_is_thin_archive (current->my_archive))
1528 filename = current->my_archive->filename;
1530 /* If the path is the same as the previous path seen,
1531 reuse it. This can happen when flattening a thin
1532 archive that contains other archives. */
1533 if (last_filename && filename_cmp (last_filename, filename) == 0)
1536 last_filename = filename;
1538 /* If the path is relative, adjust it relative to
1539 the containing archive. */
1540 if (! IS_ABSOLUTE_PATH (filename)
1541 && ! IS_ABSOLUTE_PATH (abfd->filename))
1542 normal = adjust_relative_path (filename, abfd->filename);
1546 /* In a thin archive, always store the full pathname
1547 in the extended name table. */
1548 total_namelen += strlen (normal) + 1;
1550 /* Leave room for trailing slash. */
1556 normal = normalize (current, current->filename);
1560 thislen = strlen (normal);
1562 if (thislen > maxname
1563 && (bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1566 if (thislen > maxname)
1568 /* Add one to leave room for \n. */
1569 total_namelen += thislen + 1;
1572 /* Leave room for trailing slash. */
1578 struct ar_hdr *hdr = arch_hdr (current);
1579 if (filename_ncmp (normal, hdr->ar_name, thislen) != 0
1580 || (thislen < sizeof hdr->ar_name
1581 && hdr->ar_name[thislen] != ar_padchar (current)))
1583 /* Must have been using extended format even though it
1584 didn't need to. Fix it to use normal format. */
1585 memcpy (hdr->ar_name, normal, thislen);
1586 if (thislen < maxname
1587 || (thislen == maxname && thislen < sizeof hdr->ar_name))
1588 hdr->ar_name[thislen] = ar_padchar (current);
1593 if (total_namelen == 0)
1596 *tabloc = (char *) bfd_zalloc (abfd, total_namelen);
1597 if (*tabloc == NULL)
1600 *tablen = total_namelen;
1603 last_filename = NULL;
1606 for (current = abfd->archive_head;
1608 current = current->archive_next)
1611 unsigned int thislen;
1613 const char *filename = current->filename;
1615 if (bfd_is_thin_archive (abfd))
1617 /* If the element being added is a member of another archive
1618 (i.e., we are flattening), use the containing archive's name. */
1619 if (current->my_archive
1620 && ! bfd_is_thin_archive (current->my_archive))
1621 filename = current->my_archive->filename;
1622 /* If the path is the same as the previous path seen,
1623 reuse it. This can happen when flattening a thin
1624 archive that contains other archives.
1625 If the path is relative, adjust it relative to
1626 the containing archive. */
1627 if (last_filename && filename_cmp (last_filename, filename) == 0)
1628 normal = last_filename;
1629 else if (! IS_ABSOLUTE_PATH (filename)
1630 && ! IS_ABSOLUTE_PATH (abfd->filename))
1631 normal = adjust_relative_path (filename, abfd->filename);
1637 normal = normalize (current, filename);
1642 thislen = strlen (normal);
1643 if (thislen > maxname || bfd_is_thin_archive (abfd))
1645 /* Works for now; may need to be re-engineered if we
1646 encounter an oddball archive format and want to
1647 generalise this hack. */
1648 struct ar_hdr *hdr = arch_hdr (current);
1649 if (normal == last_filename)
1650 stroff = last_stroff;
1653 strcpy (strptr, normal);
1654 if (! trailing_slash)
1655 strptr[thislen] = ARFMAG[1];
1658 strptr[thislen] = '/';
1659 strptr[thislen + 1] = ARFMAG[1];
1661 stroff = strptr - *tabloc;
1662 last_stroff = stroff;
1664 hdr->ar_name[0] = ar_padchar (current);
1665 if (bfd_is_thin_archive (abfd) && current->origin > 0)
1667 int len = snprintf (hdr->ar_name + 1, maxname - 1, "%-ld:",
1669 _bfd_ar_spacepad (hdr->ar_name + 1 + len, maxname - 1 - len,
1671 current->origin - sizeof (struct ar_hdr));
1674 _bfd_ar_spacepad (hdr->ar_name + 1, maxname - 1, "%-ld", stroff);
1675 if (normal != last_filename)
1677 strptr += thislen + 1;
1680 last_filename = filename;
1688 /* Do not construct an extended name table but transforms name field into
1689 its extended form. */
1692 _bfd_archive_bsd44_construct_extended_name_table (bfd *abfd,
1694 bfd_size_type *tablen,
1697 unsigned int maxname = abfd->xvec->ar_max_namelen;
1704 for (current = abfd->archive_head;
1706 current = current->archive_next)
1708 const char *normal = normalize (current, current->filename);
1715 for (len = 0; normal[len]; len++)
1716 if (normal[len] == ' ')
1719 if (len > maxname || has_space)
1721 struct ar_hdr *hdr = arch_hdr (current);
1723 len = (len + 3) & ~3;
1724 arch_eltdata (current)->extra_size = len;
1725 _bfd_ar_spacepad (hdr->ar_name, maxname, "#1/%lu", len);
1732 /* Write an archive header. */
1735 _bfd_generic_write_ar_hdr (bfd *archive, bfd *abfd)
1737 struct ar_hdr *hdr = arch_hdr (abfd);
1739 if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
1744 /* Write an archive header using BSD4.4 convention. */
1747 _bfd_bsd44_write_ar_hdr (bfd *archive, bfd *abfd)
1749 struct ar_hdr *hdr = arch_hdr (abfd);
1751 if (is_bsd44_extended_name (hdr->ar_name))
1753 /* This is a BSD 4.4 extended name. */
1754 const char *fullname = normalize (abfd, abfd->filename);
1755 unsigned int len = strlen (fullname);
1756 unsigned int padded_len = (len + 3) & ~3;
1758 BFD_ASSERT (padded_len == arch_eltdata (abfd)->extra_size);
1760 _bfd_ar_spacepad (hdr->ar_size, sizeof (hdr->ar_size), "%-10ld",
1761 arch_eltdata (abfd)->parsed_size + padded_len);
1763 if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
1766 if (bfd_bwrite (fullname, len, archive) != len)
1770 static const char pad[3] = { 0, 0, 0 };
1772 len = 4 - (len & 3);
1773 if (bfd_bwrite (pad, len, archive) != len)
1779 if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
1785 /* A couple of functions for creating ar_hdrs. */
1787 #ifdef HPUX_LARGE_AR_IDS
1788 /* Function to encode large UID/GID values according to HP. */
1791 hpux_uid_gid_encode (char str[6], long int id)
1795 str[5] = '@' + (id & 3);
1798 for (cnt = 4; cnt >= 0; --cnt, id >>= 6)
1799 str[cnt] = ' ' + (id & 0x3f);
1801 #endif /* HPUX_LARGE_AR_IDS */
1811 /* Takes a filename, returns an arelt_data for it, or NULL if it can't
1812 make one. The filename must refer to a filename in the filesystem.
1813 The filename field of the ar_hdr will NOT be initialized. If member
1814 is set, and it's an in-memory bfd, we fake it. */
1816 static struct areltdata *
1817 bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
1820 struct areltdata *ared;
1824 if (member && (member->flags & BFD_IN_MEMORY) != 0)
1826 /* Assume we just "made" the member, and fake it. */
1827 struct bfd_in_memory *bim = (struct bfd_in_memory *) member->iostream;
1828 time (&status.st_mtime);
1829 status.st_uid = getuid ();
1830 status.st_gid = getgid ();
1831 status.st_mode = 0644;
1832 status.st_size = bim->size;
1834 else if (stat (filename, &status) != 0)
1836 bfd_set_error (bfd_error_system_call);
1840 /* If the caller requested that the BFD generate deterministic output,
1841 fake values for modification time, UID, GID, and file mode. */
1842 if ((abfd->flags & BFD_DETERMINISTIC_OUTPUT) != 0)
1844 status.st_mtime = 0;
1847 status.st_mode = 0644;
1850 amt = sizeof (struct ar_hdr) + sizeof (struct areltdata);
1851 ared = (struct areltdata *) bfd_zalloc (abfd, amt);
1854 hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));
1856 /* ar headers are space padded, not null padded! */
1857 memset (hdr, ' ', sizeof (struct ar_hdr));
1859 _bfd_ar_spacepad (hdr->ar_date, sizeof (hdr->ar_date), "%-12ld",
1861 #ifdef HPUX_LARGE_AR_IDS
1862 /* HP has a very "special" way to handle UID/GID's with numeric values
1864 if (status.st_uid > 99999)
1865 hpux_uid_gid_encode (hdr->ar_uid, (long) status.st_uid);
1868 _bfd_ar_spacepad (hdr->ar_uid, sizeof (hdr->ar_uid), "%ld",
1870 #ifdef HPUX_LARGE_AR_IDS
1871 /* HP has a very "special" way to handle UID/GID's with numeric values
1873 if (status.st_gid > 99999)
1874 hpux_uid_gid_encode (hdr->ar_gid, (long) status.st_gid);
1877 _bfd_ar_spacepad (hdr->ar_gid, sizeof (hdr->ar_gid), "%ld",
1879 _bfd_ar_spacepad (hdr->ar_mode, sizeof (hdr->ar_mode), "%-8lo",
1881 _bfd_ar_spacepad (hdr->ar_size, sizeof (hdr->ar_size), "%-10ld",
1883 memcpy (hdr->ar_fmag, ARFMAG, 2);
1884 ared->parsed_size = status.st_size;
1885 ared->arch_header = (char *) hdr;
1890 /* Analogous to stat call. */
1893 bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
1898 if (abfd->arelt_data == NULL)
1900 bfd_set_error (bfd_error_invalid_operation);
1904 hdr = arch_hdr (abfd);
1906 #define foo(arelt, stelt, size) \
1907 buf->stelt = strtol (hdr->arelt, &aloser, size); \
1908 if (aloser == hdr->arelt) \
1911 /* Some platforms support special notations for large IDs. */
1912 #ifdef HPUX_LARGE_AR_IDS
1913 # define foo2(arelt, stelt, size) \
1914 if (hdr->arelt[5] == ' ') \
1916 foo (arelt, stelt, size); \
1921 for (buf->stelt = cnt = 0; cnt < 5; ++cnt) \
1923 if (hdr->arelt[cnt] < ' ' || hdr->arelt[cnt] > ' ' + 0x3f) \
1926 buf->stelt += hdr->arelt[cnt] - ' '; \
1928 if (hdr->arelt[5] < '@' || hdr->arelt[5] > '@' + 3) \
1931 buf->stelt += hdr->arelt[5] - '@'; \
1934 # define foo2(arelt, stelt, size) foo (arelt, stelt, size)
1937 foo (ar_date, st_mtime, 10);
1938 foo2 (ar_uid, st_uid, 10);
1939 foo2 (ar_gid, st_gid, 10);
1940 foo (ar_mode, st_mode, 8);
1942 buf->st_size = arch_eltdata (abfd)->parsed_size;
1948 bfd_dont_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1950 /* FIXME: This interacts unpleasantly with ar's quick-append option.
1951 Fortunately ic960 users will never use that option. Fixing this
1952 is very hard; fortunately I know how to do it and will do so once
1953 intel's release is out the door. */
1955 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1957 const char *filename;
1958 size_t maxlen = ar_maxnamelen (abfd);
1960 if ((bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1962 bfd_bsd_truncate_arname (abfd, pathname, arhdr);
1966 filename = normalize (abfd, pathname);
1967 if (filename == NULL)
1973 length = strlen (filename);
1975 if (length <= maxlen)
1976 memcpy (hdr->ar_name, filename, length);
1978 /* Add the padding character if there is room for it. */
1980 || (length == maxlen && length < sizeof hdr->ar_name))
1981 (hdr->ar_name)[length] = ar_padchar (abfd);
1985 bfd_bsd_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1987 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1989 const char *filename = lbasename (pathname);
1990 size_t maxlen = ar_maxnamelen (abfd);
1992 length = strlen (filename);
1994 if (length <= maxlen)
1995 memcpy (hdr->ar_name, filename, length);
1998 /* pathname: meet procrustes */
1999 memcpy (hdr->ar_name, filename, maxlen);
2003 if (length < maxlen)
2004 (hdr->ar_name)[length] = ar_padchar (abfd);
2007 /* Store name into ar header. Truncates the name to fit.
2008 1> strip pathname to be just the basename.
2009 2> if it's short enuf to fit, stuff it in.
2010 3> If it doesn't end with .o, truncate it to fit
2011 4> truncate it before the .o, append .o, stuff THAT in. */
2013 /* This is what gnu ar does. It's better but incompatible with the
2017 bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
2019 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
2021 const char *filename = lbasename (pathname);
2022 size_t maxlen = ar_maxnamelen (abfd);
2024 length = strlen (filename);
2026 if (length <= maxlen)
2027 memcpy (hdr->ar_name, filename, length);
2030 /* pathname: meet procrustes. */
2031 memcpy (hdr->ar_name, filename, maxlen);
2032 if ((filename[length - 2] == '.') && (filename[length - 1] == 'o'))
2034 hdr->ar_name[maxlen - 2] = '.';
2035 hdr->ar_name[maxlen - 1] = 'o';
2041 (hdr->ar_name)[length] = ar_padchar (abfd);
2044 /* The BFD is open for write and has its format set to bfd_archive. */
2047 _bfd_write_archive_contents (bfd *arch)
2050 char *etable = NULL;
2051 bfd_size_type elength = 0;
2052 const char *ename = NULL;
2053 bfd_boolean makemap = bfd_has_map (arch);
2054 /* If no .o's, don't bother to make a map. */
2055 bfd_boolean hasobjects = FALSE;
2056 bfd_size_type wrote;
2060 /* Verify the viability of all entries; if any of them live in the
2061 filesystem (as opposed to living in an archive open for input)
2062 then construct a fresh ar_hdr for them. */
2063 for (current = arch->archive_head;
2065 current = current->archive_next)
2067 /* This check is checking the bfds for the objects we're reading
2068 from (which are usually either an object file or archive on
2069 disk), not the archive entries we're writing to. We don't
2070 actually create bfds for the archive members, we just copy
2071 them byte-wise when we write out the archive. */
2072 if (bfd_write_p (current))
2074 bfd_set_error (bfd_error_invalid_operation);
2077 if (!current->arelt_data)
2079 current->arelt_data =
2080 bfd_ar_hdr_from_filesystem (arch, current->filename, current);
2081 if (!current->arelt_data)
2084 /* Put in the file name. */
2085 BFD_SEND (arch, _bfd_truncate_arname,
2086 (arch, current->filename, (char *) arch_hdr (current)));
2089 if (makemap && ! hasobjects)
2090 { /* Don't bother if we won't make a map! */
2091 if ((bfd_check_format (current, bfd_object)))
2096 if (!BFD_SEND (arch, _bfd_construct_extended_name_table,
2097 (arch, &etable, &elength, &ename)))
2100 if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0)
2103 if (bfd_is_thin_archive (arch))
2105 wrote = bfd_bwrite (armag, SARMAG, arch);
2106 if (wrote != SARMAG)
2109 if (makemap && hasobjects)
2111 if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength))
2119 memset (&hdr, ' ', sizeof (struct ar_hdr));
2120 memcpy (hdr.ar_name, ename, strlen (ename));
2121 /* Round size up to even number in archive header. */
2122 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld",
2123 (elength + 1) & ~(bfd_size_type) 1);
2124 memcpy (hdr.ar_fmag, ARFMAG, 2);
2125 if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2126 != sizeof (struct ar_hdr))
2127 || bfd_bwrite (etable, elength, arch) != elength)
2129 if ((elength % 2) == 1)
2131 if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)
2136 for (current = arch->archive_head;
2138 current = current->archive_next)
2140 char buffer[DEFAULT_BUFFERSIZE];
2141 unsigned int remaining = arelt_size (current);
2143 /* Write ar header. */
2144 if (!_bfd_write_ar_hdr (arch, current))
2146 if (bfd_is_thin_archive (arch))
2148 if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
2153 unsigned int amt = DEFAULT_BUFFERSIZE;
2155 if (amt > remaining)
2158 if (bfd_bread (buffer, amt, current) != amt)
2160 if (bfd_get_error () != bfd_error_system_call)
2161 bfd_set_error (bfd_error_file_truncated);
2164 if (bfd_bwrite (buffer, amt, arch) != amt)
2169 if ((arelt_size (current) % 2) == 1)
2171 if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)
2176 if (makemap && hasobjects)
2178 /* Verify the timestamp in the archive file. If it would not be
2179 accepted by the linker, rewrite it until it would be. If
2180 anything odd happens, break out and just return. (The
2181 Berkeley linker checks the timestamp and refuses to read the
2182 table-of-contents if it is >60 seconds less than the file's
2183 modified-time. That painful hack requires this painful hack. */
2187 if (bfd_update_armap_timestamp (arch))
2189 (*_bfd_error_handler)
2190 (_("Warning: writing archive was slow: rewriting timestamp\n"));
2192 while (++tries < 6);
2198 bfd_set_error (bfd_error_on_input, current, bfd_get_error ());
2202 /* Note that the namidx for the first symbol is 0. */
2205 _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
2207 char *first_name = NULL;
2209 file_ptr elt_no = 0;
2210 struct orl *map = NULL;
2211 unsigned int orl_max = 1024; /* Fine initial default. */
2212 unsigned int orl_count = 0;
2214 asymbol **syms = NULL;
2219 /* Dunno if this is the best place for this info... */
2221 elength += sizeof (struct ar_hdr);
2222 elength += elength % 2;
2224 amt = orl_max * sizeof (struct orl);
2225 map = (struct orl *) bfd_malloc (amt);
2229 /* We put the symbol names on the arch objalloc, and then discard
2231 first_name = (char *) bfd_alloc (arch, 1);
2232 if (first_name == NULL)
2235 /* Drop all the files called __.SYMDEF, we're going to make our own. */
2236 while (arch->archive_head
2237 && strcmp (arch->archive_head->filename, "__.SYMDEF") == 0)
2238 arch->archive_head = arch->archive_head->archive_next;
2240 /* Map over each element. */
2241 for (current = arch->archive_head;
2243 current = current->archive_next, elt_no++)
2245 if (bfd_check_format (current, bfd_object)
2246 && (bfd_get_file_flags (current) & HAS_SYMS) != 0)
2252 storage = bfd_get_symtab_upper_bound (current);
2258 if (storage > syms_max)
2263 syms = (asymbol **) bfd_malloc (syms_max);
2267 symcount = bfd_canonicalize_symtab (current, syms);
2271 /* Now map over all the symbols, picking out the ones we
2273 for (src_count = 0; src_count < symcount; src_count++)
2275 flagword flags = (syms[src_count])->flags;
2276 asection *sec = syms[src_count]->section;
2278 if ((flags & BSF_GLOBAL
2280 || flags & BSF_INDIRECT
2281 || flags & BSF_GNU_UNIQUE
2282 || bfd_is_com_section (sec))
2283 && ! bfd_is_und_section (sec))
2285 bfd_size_type namelen;
2286 struct orl *new_map;
2288 /* This symbol will go into the archive header. */
2289 if (orl_count == orl_max)
2292 amt = orl_max * sizeof (struct orl);
2293 new_map = (struct orl *) bfd_realloc (map, amt);
2294 if (new_map == NULL)
2300 namelen = strlen (syms[src_count]->name);
2301 amt = sizeof (char *);
2302 map[orl_count].name = (char **) bfd_alloc (arch, amt);
2303 if (map[orl_count].name == NULL)
2305 *(map[orl_count].name) = (char *) bfd_alloc (arch,
2307 if (*(map[orl_count].name) == NULL)
2309 strcpy (*(map[orl_count].name), syms[src_count]->name);
2310 map[orl_count].u.abfd = current;
2311 map[orl_count].namidx = stridx;
2313 stridx += namelen + 1;
2319 /* Now ask the BFD to free up any cached information, so we
2320 don't fill all of memory with symbol tables. */
2321 if (! bfd_free_cached_info (current))
2326 /* OK, now we have collected all the data, let's write them out. */
2327 ret = BFD_SEND (arch, write_armap,
2328 (arch, elength, map, orl_count, stridx));
2334 if (first_name != NULL)
2335 bfd_release (arch, first_name);
2344 if (first_name != NULL)
2345 bfd_release (arch, first_name);
2351 bsd_write_armap (bfd *arch,
2352 unsigned int elength,
2354 unsigned int orl_count,
2357 int padit = stridx & 1;
2358 unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE;
2359 unsigned int stringsize = stridx + padit;
2360 /* Include 8 bytes to store ranlibsize and stringsize in output. */
2361 unsigned int mapsize = ranlibsize + stringsize + 8;
2363 bfd *current = arch->archive_head;
2364 bfd *last_elt = current; /* Last element arch seen. */
2370 firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
2372 /* If deterministic, we use 0 as the timestamp in the map.
2373 Some linkers may require that the archive filesystem modification
2374 time is less than (or near to) the archive map timestamp. Those
2375 linkers should not be used with deterministic mode. (GNU ld and
2376 Gold do not have this restriction.) */
2377 bfd_ardata (arch)->armap_timestamp = 0;
2380 if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0)
2382 struct stat statbuf;
2384 if (stat (arch->filename, &statbuf) == 0)
2385 bfd_ardata (arch)->armap_timestamp = (statbuf.st_mtime
2386 + ARMAP_TIME_OFFSET);
2391 memset (&hdr, ' ', sizeof (struct ar_hdr));
2392 memcpy (hdr.ar_name, RANLIBMAG, strlen (RANLIBMAG));
2393 bfd_ardata (arch)->armap_datepos = (SARMAG
2394 + offsetof (struct ar_hdr, ar_date[0]));
2395 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2396 bfd_ardata (arch)->armap_timestamp);
2397 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", uid);
2398 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", gid);
2399 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld", mapsize);
2400 memcpy (hdr.ar_fmag, ARFMAG, 2);
2401 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2402 != sizeof (struct ar_hdr))
2404 H_PUT_32 (arch, ranlibsize, temp);
2405 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
2408 for (count = 0; count < orl_count; count++)
2410 bfd_byte buf[BSD_SYMDEF_SIZE];
2412 if (map[count].u.abfd != last_elt)
2416 struct areltdata *ared = arch_eltdata (current);
2418 firstreal += (ared->parsed_size + ared->extra_size
2419 + sizeof (struct ar_hdr));
2420 firstreal += firstreal % 2;
2421 current = current->archive_next;
2423 while (current != map[count].u.abfd);
2427 H_PUT_32 (arch, map[count].namidx, buf);
2428 H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE);
2429 if (bfd_bwrite (buf, BSD_SYMDEF_SIZE, arch)
2434 /* Now write the strings themselves. */
2435 H_PUT_32 (arch, stringsize, temp);
2436 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
2438 for (count = 0; count < orl_count; count++)
2440 size_t len = strlen (*map[count].name) + 1;
2442 if (bfd_bwrite (*map[count].name, len, arch) != len)
2446 /* The spec sez this should be a newline. But in order to be
2447 bug-compatible for sun's ar we use a null. */
2450 if (bfd_bwrite ("", 1, arch) != 1)
2457 /* At the end of archive file handling, update the timestamp in the
2458 file, so the linker will accept it.
2460 Return TRUE if the timestamp was OK, or an unusual problem happened.
2461 Return FALSE if we updated the timestamp. */
2464 _bfd_archive_bsd_update_armap_timestamp (bfd *arch)
2466 struct stat archstat;
2469 /* If creating deterministic archives, just leave the timestamp as-is. */
2470 if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) != 0)
2473 /* Flush writes, get last-write timestamp from file, and compare it
2474 to the timestamp IN the file. */
2476 if (bfd_stat (arch, &archstat) == -1)
2478 bfd_perror (_("Reading archive file mod timestamp"));
2480 /* Can't read mod time for some reason. */
2483 if (((long) archstat.st_mtime) <= bfd_ardata (arch)->armap_timestamp)
2484 /* OK by the linker's rules. */
2487 /* Update the timestamp. */
2488 bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET;
2490 /* Prepare an ASCII version suitable for writing. */
2491 memset (hdr.ar_date, ' ', sizeof (hdr.ar_date));
2492 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2493 bfd_ardata (arch)->armap_timestamp);
2495 /* Write it into the file. */
2496 bfd_ardata (arch)->armap_datepos = (SARMAG
2497 + offsetof (struct ar_hdr, ar_date[0]));
2498 if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0
2499 || (bfd_bwrite (hdr.ar_date, sizeof (hdr.ar_date), arch)
2500 != sizeof (hdr.ar_date)))
2502 bfd_perror (_("Writing updated armap timestamp"));
2504 /* Some error while writing. */
2508 /* We updated the timestamp successfully. */
2512 /* A coff armap looks like :
2514 struct ar_hdr with name = '/'
2516 offset of file for symbol 0
2517 offset of file for symbol 1
2519 offset of file for symbol n-1
2526 coff_write_armap (bfd *arch,
2527 unsigned int elength,
2529 unsigned int symbol_count,
2532 /* The size of the ranlib is the number of exported symbols in the
2533 archive * the number of bytes in an int, + an int for the count. */
2534 unsigned int ranlibsize = (symbol_count * 4) + 4;
2535 unsigned int stringsize = stridx;
2536 unsigned int mapsize = stringsize + ranlibsize;
2537 unsigned int archive_member_file_ptr;
2538 bfd *current = arch->archive_head;
2541 int padit = mapsize & 1;
2546 /* Work out where the first object file will go in the archive. */
2547 archive_member_file_ptr = (mapsize
2549 + sizeof (struct ar_hdr)
2552 memset (&hdr, ' ', sizeof (struct ar_hdr));
2553 hdr.ar_name[0] = '/';
2554 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld",
2556 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2557 ((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0
2558 ? time (NULL) : 0));
2559 /* This, at least, is what Intel coff sets the values to. */
2560 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", 0);
2561 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", 0);
2562 _bfd_ar_spacepad (hdr.ar_mode, sizeof (hdr.ar_mode), "%-7lo", 0);
2563 memcpy (hdr.ar_fmag, ARFMAG, 2);
2565 /* Write the ar header for this item and the number of symbols. */
2566 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2567 != sizeof (struct ar_hdr))
2570 if (!bfd_write_bigendian_4byte_int (arch, symbol_count))
2573 /* Two passes, first write the file offsets for each symbol -
2574 remembering that each offset is on a two byte boundary. */
2576 /* Write out the file offset for the file associated with each
2577 symbol, and remember to keep the offsets padded out. */
2579 current = arch->archive_head;
2581 while (current != NULL && count < symbol_count)
2583 /* For each symbol which is used defined in this object, write
2584 out the object file's address in the archive. */
2586 while (count < symbol_count && map[count].u.abfd == current)
2588 if (!bfd_write_bigendian_4byte_int (arch, archive_member_file_ptr))
2592 archive_member_file_ptr += sizeof (struct ar_hdr);
2593 if (! bfd_is_thin_archive (arch))
2595 /* Add size of this archive entry. */
2596 archive_member_file_ptr += arelt_size (current);
2597 /* Remember about the even alignment. */
2598 archive_member_file_ptr += archive_member_file_ptr % 2;
2600 current = current->archive_next;
2603 /* Now write the strings themselves. */
2604 for (count = 0; count < symbol_count; count++)
2606 size_t len = strlen (*map[count].name) + 1;
2608 if (bfd_bwrite (*map[count].name, len, arch) != len)
2612 /* The spec sez this should be a newline. But in order to be
2613 bug-compatible for arc960 we use a null. */
2616 if (bfd_bwrite ("", 1, arch) != 1)