Add code to cope with nested archives.
[external/binutils.git] / bfd / archive.c
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
4    Free Software Foundation, Inc.
5    Written by Cygnus Support.  Mostly Gumby Henkel-Wallace's fault.
6
7    This file is part of BFD, the Binary File Descriptor library.
8
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.
13
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.
18
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.  */
22
23 /*
24 @setfilename archive-info
25 SECTION
26         Archives
27
28 DESCRIPTION
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.
31
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.
39
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.
44
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.
50
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!
56
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
66         homogeneous.
67
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
73         of a restriction.
74
75         Archives are supported in BFD in <<archive.c>>.
76
77 */
78
79 /* Assumes:
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).
83 */
84
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.
93
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.
97
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.
102
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.
106 */
107
108 /* Summary of archive member names:
109
110  Symbol table (must be first):
111  "__.SYMDEF       " - Symbol table, Berkeley style, produced by ranlib.
112  "/               " - Symbol table, system 5 style.
113
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).
117
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).
121
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.
128  */
129
130 #include "bfd.h"
131 #include "sysdep.h"
132 #include "libbfd.h"
133 #include "aout/ar.h"
134 #include "aout/ranlib.h"
135 #include "safe-ctype.h"
136
137 #ifndef errno
138 extern int errno;
139 #endif
140
141 #ifdef GNU960
142 #define BFD_GNU960_ARMAG(abfd)  (BFD_COFF_FILE_P((abfd)) ? ARMAG : ARMAGB)
143 #endif
144
145 /* We keep a cache of archive filepointers to archive elements to
146    speed up searching the archive by filepos.  We only add an entry to
147    the cache when we actually read one.  We also don't sort the cache;
148    it's generally short enough to search linearly.
149    Note that the pointers here point to the front of the ar_hdr, not
150    to the front of the contents!  */
151 struct ar_cache {
152   file_ptr ptr;
153   bfd *arelt;
154   struct ar_cache *next;
155 };
156
157 #define ar_padchar(abfd) ((abfd)->xvec->ar_pad_char)
158 #define ar_maxnamelen(abfd) ((abfd)->xvec->ar_max_namelen)
159
160 #define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data))
161 #define arch_hdr(bfd) ((struct ar_hdr *) arch_eltdata(bfd)->arch_header)
162
163 \f
164 bfd_boolean
165 _bfd_generic_mkarchive (bfd *abfd)
166 {
167   bfd_size_type amt = sizeof (struct artdata);
168
169   abfd->tdata.aout_ar_data = bfd_zalloc (abfd, amt);
170   if (bfd_ardata (abfd) == NULL)
171     return FALSE;
172
173   bfd_ardata (abfd)->cache = NULL;
174   bfd_ardata (abfd)->archive_head = NULL;
175   bfd_ardata (abfd)->symdefs = NULL;
176   bfd_ardata (abfd)->extended_names = NULL;
177   bfd_ardata (abfd)->tdata = NULL;
178
179   return TRUE;
180 }
181
182 /*
183 FUNCTION
184         bfd_get_next_mapent
185
186 SYNOPSIS
187         symindex bfd_get_next_mapent
188           (bfd *abfd, symindex previous, carsym **sym);
189
190 DESCRIPTION
191         Step through archive @var{abfd}'s symbol table (if it
192         has one).  Successively update @var{sym} with the next symbol's
193         information, returning that symbol's (internal) index into the
194         symbol table.
195
196         Supply <<BFD_NO_MORE_SYMBOLS>> as the @var{previous} entry to get
197         the first one; returns <<BFD_NO_MORE_SYMBOLS>> when you've already
198         got the last one.
199
200         A <<carsym>> is a canonical archive symbol.  The only
201         user-visible element is its name, a null-terminated string.
202 */
203
204 symindex
205 bfd_get_next_mapent (bfd *abfd, symindex prev, carsym **entry)
206 {
207   if (!bfd_has_map (abfd))
208     {
209       bfd_set_error (bfd_error_invalid_operation);
210       return BFD_NO_MORE_SYMBOLS;
211     }
212
213   if (prev == BFD_NO_MORE_SYMBOLS)
214     prev = 0;
215   else
216     ++prev;
217   if (prev >= bfd_ardata (abfd)->symdef_count)
218     return BFD_NO_MORE_SYMBOLS;
219
220   *entry = (bfd_ardata (abfd)->symdefs + prev);
221   return prev;
222 }
223
224 /* To be called by backends only.  */
225
226 bfd *
227 _bfd_create_empty_archive_element_shell (bfd *obfd)
228 {
229   return _bfd_new_bfd_contained_in (obfd);
230 }
231
232 /*
233 FUNCTION
234         bfd_set_archive_head
235
236 SYNOPSIS
237         bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);
238
239 DESCRIPTION
240         Set the head of the chain of
241         BFDs contained in the archive @var{output} to @var{new_head}.
242 */
243
244 bfd_boolean
245 bfd_set_archive_head (bfd *output_archive, bfd *new_head)
246 {
247   output_archive->archive_head = new_head;
248   return TRUE;
249 }
250
251 bfd *
252 _bfd_look_for_bfd_in_cache (bfd *arch_bfd, file_ptr filepos)
253 {
254   struct ar_cache *current;
255
256   for (current = bfd_ardata (arch_bfd)->cache; current != NULL;
257        current = current->next)
258     if (current->ptr == filepos)
259       return current->arelt;
260
261   return NULL;
262 }
263
264 /* Kind of stupid to call cons for each one, but we don't do too many.  */
265
266 bfd_boolean
267 _bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt)
268 {
269   bfd_size_type amt = sizeof (struct ar_cache);
270
271   struct ar_cache *new_cache = bfd_zalloc (arch_bfd, amt);
272   if (new_cache == NULL)
273     return FALSE;
274
275   new_cache->ptr = filepos;
276   new_cache->arelt = new_elt;
277   new_cache->next = NULL;
278   if (bfd_ardata (arch_bfd)->cache == NULL)
279     bfd_ardata (arch_bfd)->cache = new_cache;
280   else
281     {
282       struct ar_cache *current = bfd_ardata (arch_bfd)->cache;
283
284       while (current->next != NULL)
285         current = current->next;
286       current->next = new_cache;
287     }
288
289   return TRUE;
290 }
291 \f
292 /* The name begins with space.  Hence the rest of the name is an index into
293    the string table.  */
294
295 static char *
296 get_extended_arelt_filename (bfd *arch, const char *name)
297 {
298   unsigned long index = 0;
299
300   /* Should extract string so that I can guarantee not to overflow into
301      the next region, but I'm too lazy.  */
302   errno = 0;
303   /* Skip first char, which is '/' in SVR4 or ' ' in some other variants.  */
304   index = strtol (name + 1, NULL, 10);
305   if (errno != 0)
306     {
307       bfd_set_error (bfd_error_malformed_archive);
308       return NULL;
309     }
310
311   return bfd_ardata (arch)->extended_names + index;
312 }
313
314 /* This functions reads an arch header and returns an areltdata pointer, or
315    NULL on error.
316
317    Presumes the file pointer is already in the right place (ie pointing
318    to the ar_hdr in the file).   Moves the file pointer; on success it
319    should be pointing to the front of the file contents; on failure it
320    could have been moved arbitrarily.  */
321
322 void *
323 _bfd_generic_read_ar_hdr (bfd *abfd)
324 {
325   return _bfd_generic_read_ar_hdr_mag (abfd, NULL);
326 }
327
328 /* Alpha ECOFF uses an optional different ARFMAG value, so we have a
329    variant of _bfd_generic_read_ar_hdr which accepts a magic string.  */
330
331 void *
332 _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
333 {
334   struct ar_hdr hdr;
335   char *hdrp = (char *) &hdr;
336   size_t parsed_size;
337   struct areltdata *ared;
338   char *filename = NULL;
339   bfd_size_type namelen = 0;
340   bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
341   char *allocptr = 0;
342
343   if (bfd_bread (hdrp, sizeof (struct ar_hdr), abfd) != sizeof (struct ar_hdr))
344     {
345       if (bfd_get_error () != bfd_error_system_call)
346         bfd_set_error (bfd_error_no_more_archived_files);
347       return NULL;
348     }
349   if (strncmp (hdr.ar_fmag, ARFMAG, 2) != 0
350       && (mag == NULL
351           || strncmp (hdr.ar_fmag, mag, 2) != 0))
352     {
353       bfd_set_error (bfd_error_malformed_archive);
354       return NULL;
355     }
356
357   errno = 0;
358   parsed_size = strtol (hdr.ar_size, NULL, 10);
359   if (errno != 0)
360     {
361       bfd_set_error (bfd_error_malformed_archive);
362       return NULL;
363     }
364
365   /* Extract the filename from the archive - there are two ways to
366      specify an extended name table, either the first char of the
367      name is a space, or it's a slash.  */
368   if ((hdr.ar_name[0] == '/'
369        || (hdr.ar_name[0] == ' '
370            && memchr (hdr.ar_name, '/', ar_maxnamelen (abfd)) == NULL))
371       && bfd_ardata (abfd)->extended_names != NULL)
372     {
373       filename = get_extended_arelt_filename (abfd, hdr.ar_name);
374       if (filename == NULL)
375         {
376           bfd_set_error (bfd_error_malformed_archive);
377           return NULL;
378         }
379     }
380   /* BSD4.4-style long filename.
381      Only implemented for reading, so far!  */
382   else if (hdr.ar_name[0] == '#'
383            && hdr.ar_name[1] == '1'
384            && hdr.ar_name[2] == '/'
385            && ISDIGIT (hdr.ar_name[3]))
386     {
387       /* BSD-4.4 extended name */
388       namelen = atoi (&hdr.ar_name[3]);
389       allocsize += namelen + 1;
390       parsed_size -= namelen;
391
392       allocptr = bfd_zalloc (abfd, allocsize);
393       if (allocptr == NULL)
394         return NULL;
395       filename = (allocptr
396                   + sizeof (struct areltdata)
397                   + sizeof (struct ar_hdr));
398       if (bfd_bread (filename, namelen, abfd) != namelen)
399         {
400           if (bfd_get_error () != bfd_error_system_call)
401             bfd_set_error (bfd_error_no_more_archived_files);
402           return NULL;
403         }
404       filename[namelen] = '\0';
405     }
406   else
407     {
408       /* We judge the end of the name by looking for '/' or ' '.
409          Note:  The SYSV format (terminated by '/') allows embedded
410          spaces, so only look for ' ' if we don't find '/'.  */
411
412       char *e;
413       e = memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
414       if (e == NULL)
415         {
416           e = memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
417           if (e == NULL)
418             e = memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
419         }
420
421       if (e != NULL)
422         namelen = e - hdr.ar_name;
423       else
424         {
425           /* If we didn't find a termination character, then the name
426              must be the entire field.  */
427           namelen = ar_maxnamelen (abfd);
428         }
429
430       allocsize += namelen + 1;
431     }
432
433   if (!allocptr)
434     {
435       allocptr = bfd_zalloc (abfd, allocsize);
436       if (allocptr == NULL)
437         return NULL;
438     }
439
440   ared = (struct areltdata *) allocptr;
441
442   ared->arch_header = allocptr + sizeof (struct areltdata);
443   memcpy (ared->arch_header, &hdr, sizeof (struct ar_hdr));
444   ared->parsed_size = parsed_size;
445
446   if (filename != NULL)
447     ared->filename = filename;
448   else
449     {
450       ared->filename = allocptr + (sizeof (struct areltdata) +
451                                    sizeof (struct ar_hdr));
452       if (namelen)
453         memcpy (ared->filename, hdr.ar_name, namelen);
454       ared->filename[namelen] = '\0';
455     }
456
457   return ared;
458 }
459 \f
460 /* This is an internal function; it's mainly used when indexing
461    through the archive symbol table, but also used to get the next
462    element, since it handles the bookkeeping so nicely for us.  */
463
464 bfd *
465 _bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos)
466 {
467   struct areltdata *new_areldata;
468   bfd *n_nfd;
469
470   if (archive->my_archive)
471     {
472       filepos += archive->origin;
473       archive = archive->my_archive;
474     }
475
476   n_nfd = _bfd_look_for_bfd_in_cache (archive, filepos);
477   if (n_nfd)
478     return n_nfd;
479
480   if (0 > bfd_seek (archive, filepos, SEEK_SET))
481     return NULL;
482
483   if ((new_areldata = _bfd_read_ar_hdr (archive)) == NULL)
484     return NULL;
485
486   n_nfd = _bfd_create_empty_archive_element_shell (archive);
487   if (n_nfd == NULL)
488     {
489       bfd_release (archive, new_areldata);
490       return NULL;
491     }
492
493   n_nfd->origin = bfd_tell (archive);
494   n_nfd->arelt_data = new_areldata;
495   n_nfd->filename = new_areldata->filename;
496
497   if (_bfd_add_bfd_to_archive_cache (archive, filepos, n_nfd))
498     return n_nfd;
499
500   /* Huh?  */
501   bfd_release (archive, n_nfd);
502   bfd_release (archive, new_areldata);
503   return NULL;
504 }
505
506 /* Return the BFD which is referenced by the symbol in ABFD indexed by
507    INDEX.  INDEX should have been returned by bfd_get_next_mapent.  */
508
509 bfd *
510 _bfd_generic_get_elt_at_index (bfd *abfd, symindex index)
511 {
512   carsym *entry;
513
514   entry = bfd_ardata (abfd)->symdefs + index;
515   return _bfd_get_elt_at_filepos (abfd, entry->file_offset);
516 }
517
518 /*
519 FUNCTION
520         bfd_openr_next_archived_file
521
522 SYNOPSIS
523         bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous);
524
525 DESCRIPTION
526         Provided a BFD, @var{archive}, containing an archive and NULL, open
527         an input BFD on the first contained element and returns that.
528         Subsequent calls should pass
529         the archive and the previous return value to return a created
530         BFD to the next contained element. NULL is returned when there
531         are no more.
532 */
533
534 bfd *
535 bfd_openr_next_archived_file (bfd *archive, bfd *last_file)
536 {
537   if ((bfd_get_format (archive) != bfd_archive) ||
538       (archive->direction == write_direction))
539     {
540       bfd_set_error (bfd_error_invalid_operation);
541       return NULL;
542     }
543
544   return BFD_SEND (archive,
545                    openr_next_archived_file, (archive, last_file));
546 }
547
548 bfd *
549 bfd_generic_openr_next_archived_file (bfd *archive, bfd *last_file)
550 {
551   file_ptr filestart;
552
553   if (!last_file)
554     filestart = bfd_ardata (archive)->first_file_filepos;
555   else
556     {
557       unsigned int size = arelt_size (last_file);
558       filestart = last_file->origin + size;
559       if (archive->my_archive)
560         filestart -= archive->origin;
561       /* Pad to an even boundary...
562          Note that last_file->origin can be odd in the case of
563          BSD-4.4-style element with a long odd size.  */
564       filestart += filestart % 2;
565     }
566
567   return _bfd_get_elt_at_filepos (archive, filestart);
568 }
569
570 const bfd_target *
571 bfd_generic_archive_p (bfd *abfd)
572 {
573   struct artdata *tdata_hold;
574   char armag[SARMAG + 1];
575   bfd_size_type amt;
576
577   if (bfd_bread (armag, SARMAG, abfd) != SARMAG)
578     {
579       if (bfd_get_error () != bfd_error_system_call)
580         bfd_set_error (bfd_error_wrong_format);
581       return NULL;
582     }
583
584 #ifdef GNU960
585   if (strncmp (armag, BFD_GNU960_ARMAG (abfd), SARMAG) != 0)
586     return 0;
587 #else
588   if (strncmp (armag, ARMAG, SARMAG) != 0 &&
589       strncmp (armag, ARMAGB, SARMAG) != 0)
590     return 0;
591 #endif
592
593   tdata_hold = bfd_ardata (abfd);
594
595   amt = sizeof (struct artdata);
596   bfd_ardata (abfd) = bfd_zalloc (abfd, amt);
597   if (bfd_ardata (abfd) == NULL)
598     {
599       bfd_ardata (abfd) = tdata_hold;
600       return NULL;
601     }
602
603   bfd_ardata (abfd)->first_file_filepos = SARMAG;
604   bfd_ardata (abfd)->cache = NULL;
605   bfd_ardata (abfd)->archive_head = NULL;
606   bfd_ardata (abfd)->symdefs = NULL;
607   bfd_ardata (abfd)->extended_names = NULL;
608   bfd_ardata (abfd)->tdata = NULL;
609
610   if (!BFD_SEND (abfd, _bfd_slurp_armap, (abfd))
611       || !BFD_SEND (abfd, _bfd_slurp_extended_name_table, (abfd)))
612     {
613       if (bfd_get_error () != bfd_error_system_call)
614         bfd_set_error (bfd_error_wrong_format);
615       bfd_release (abfd, bfd_ardata (abfd));
616       bfd_ardata (abfd) = tdata_hold;
617       return NULL;
618     }
619
620   if (bfd_has_map (abfd))
621     {
622       bfd *first;
623
624       /* This archive has a map, so we may presume that the contents
625          are object files.  Make sure that if the first file in the
626          archive can be recognized as an object file, it is for this
627          target.  If not, assume that this is the wrong format.  If
628          the first file is not an object file, somebody is doing
629          something weird, and we permit it so that ar -t will work.
630
631          This is done because any normal format will recognize any
632          normal archive, regardless of the format of the object files.
633          We do accept an empty archive.  */
634
635       first = bfd_openr_next_archived_file (abfd, NULL);
636       if (first != NULL)
637         {
638           bfd_boolean fail;
639
640           first->target_defaulted = FALSE;
641           fail = FALSE;
642           if (bfd_check_format (first, bfd_object)
643               && first->xvec != abfd->xvec)
644             {
645 #if 0
646               /* We ought to close `first' here, but we can't, because
647                  we have no way to remove it from the archive cache.
648                  It's close to impossible to figure out when we can
649                  release bfd_ardata.  FIXME.  */
650               bfd_close (first);
651               bfd_release (abfd, bfd_ardata (abfd));
652 #endif
653               bfd_set_error (bfd_error_wrong_object_format);
654               bfd_ardata (abfd) = tdata_hold;
655               return NULL;
656             }
657           /* And we ought to close `first' here too.  */
658         }
659     }
660
661   return abfd->xvec;
662 }
663
664 /* Some constants for a 32 bit BSD archive structure.  We do not
665    support 64 bit archives presently; so far as I know, none actually
666    exist.  Supporting them would require changing these constants, and
667    changing some H_GET_32 to H_GET_64.  */
668
669 /* The size of an external symdef structure.  */
670 #define BSD_SYMDEF_SIZE 8
671
672 /* The offset from the start of a symdef structure to the file offset.  */
673 #define BSD_SYMDEF_OFFSET_SIZE 4
674
675 /* The size of the symdef count.  */
676 #define BSD_SYMDEF_COUNT_SIZE 4
677
678 /* The size of the string count.  */
679 #define BSD_STRING_COUNT_SIZE 4
680
681 /* Returns FALSE on error, TRUE otherwise.  */
682
683 static bfd_boolean
684 do_slurp_bsd_armap (bfd *abfd)
685 {
686   struct areltdata *mapdata;
687   unsigned int counter;
688   bfd_byte *raw_armap, *rbase;
689   struct artdata *ardata = bfd_ardata (abfd);
690   char *stringbase;
691   bfd_size_type parsed_size, amt;
692   carsym *set;
693
694   mapdata = _bfd_read_ar_hdr (abfd);
695   if (mapdata == NULL)
696     return FALSE;
697   parsed_size = mapdata->parsed_size;
698   bfd_release (abfd, mapdata);  /* Don't need it any more.  */
699
700   raw_armap = bfd_zalloc (abfd, parsed_size);
701   if (raw_armap == NULL)
702     return FALSE;
703
704   if (bfd_bread (raw_armap, parsed_size, abfd) != parsed_size)
705     {
706       if (bfd_get_error () != bfd_error_system_call)
707         bfd_set_error (bfd_error_malformed_archive);
708     byebye:
709       bfd_release (abfd, raw_armap);
710       return FALSE;
711     }
712
713   ardata->symdef_count = H_GET_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE;
714
715   if (ardata->symdef_count * BSD_SYMDEF_SIZE >
716       parsed_size - BSD_SYMDEF_COUNT_SIZE)
717     {
718       /* Probably we're using the wrong byte ordering.  */
719       bfd_set_error (bfd_error_wrong_format);
720       goto byebye;
721     }
722
723   ardata->cache = 0;
724   rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE;
725   stringbase = ((char *) rbase
726                 + ardata->symdef_count * BSD_SYMDEF_SIZE
727                 + BSD_STRING_COUNT_SIZE);
728   amt = ardata->symdef_count * sizeof (carsym);
729   ardata->symdefs = bfd_alloc (abfd, amt);
730   if (!ardata->symdefs)
731     return FALSE;
732
733   for (counter = 0, set = ardata->symdefs;
734        counter < ardata->symdef_count;
735        counter++, set++, rbase += BSD_SYMDEF_SIZE)
736     {
737       set->name = H_GET_32 (abfd, rbase) + stringbase;
738       set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
739     }
740
741   ardata->first_file_filepos = bfd_tell (abfd);
742   /* Pad to an even boundary if you have to.  */
743   ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
744   /* FIXME, we should provide some way to free raw_ardata when
745      we are done using the strings from it.  For now, it seems
746      to be allocated on an objalloc anyway...  */
747   bfd_has_map (abfd) = TRUE;
748   return TRUE;
749 }
750
751 /* Returns FALSE on error, TRUE otherwise.  */
752
753 static bfd_boolean
754 do_slurp_coff_armap (bfd *abfd)
755 {
756   struct areltdata *mapdata;
757   int *raw_armap, *rawptr;
758   struct artdata *ardata = bfd_ardata (abfd);
759   char *stringbase;
760   bfd_size_type stringsize;
761   unsigned int parsed_size;
762   carsym *carsyms;
763   bfd_size_type nsymz;          /* Number of symbols in armap.  */
764   bfd_vma (*swap) (const void *);
765   char int_buf[sizeof (long)];
766   bfd_size_type carsym_size, ptrsize;
767   unsigned int i;
768
769   mapdata = _bfd_read_ar_hdr (abfd);
770   if (mapdata == NULL)
771     return FALSE;
772   parsed_size = mapdata->parsed_size;
773   bfd_release (abfd, mapdata);  /* Don't need it any more.  */
774
775   if (bfd_bread (int_buf, 4, abfd) != 4)
776     {
777       if (bfd_get_error () != bfd_error_system_call)
778         bfd_set_error (bfd_error_malformed_archive);
779       return FALSE;
780     }
781   /* It seems that all numeric information in a coff archive is always
782      in big endian format, nomatter the host or target.  */
783   swap = bfd_getb32;
784   nsymz = bfd_getb32 (int_buf);
785   stringsize = parsed_size - (4 * nsymz) - 4;
786
787 #if 1
788   /* ... except that some archive formats are broken, and it may be our
789      fault - the i960 little endian coff sometimes has big and sometimes
790      little, because our tools changed.  Here's a horrible hack to clean
791      up the crap.  */
792
793   if (stringsize > 0xfffff
794       && bfd_get_arch (abfd) == bfd_arch_i960
795       && bfd_get_flavour (abfd) == bfd_target_coff_flavour)
796     {
797       /* This looks dangerous, let's do it the other way around.  */
798       nsymz = bfd_getl32 (int_buf);
799       stringsize = parsed_size - (4 * nsymz) - 4;
800       swap = bfd_getl32;
801     }
802 #endif
803
804   /* The coff armap must be read sequentially.  So we construct a
805      bsd-style one in core all at once, for simplicity.  */
806
807   carsym_size = (nsymz * sizeof (carsym));
808   ptrsize = (4 * nsymz);
809
810   ardata->symdefs = bfd_zalloc (abfd, carsym_size + stringsize + 1);
811   if (ardata->symdefs == NULL)
812     return FALSE;
813   carsyms = ardata->symdefs;
814   stringbase = ((char *) ardata->symdefs) + carsym_size;
815
816   /* Allocate and read in the raw offsets.  */
817   raw_armap = bfd_alloc (abfd, ptrsize);
818   if (raw_armap == NULL)
819     goto release_symdefs;
820   if (bfd_bread (raw_armap, ptrsize, abfd) != ptrsize
821       || (bfd_bread (stringbase, stringsize, abfd) != stringsize))
822     {
823       if (bfd_get_error () != bfd_error_system_call)
824         bfd_set_error (bfd_error_malformed_archive);
825       goto release_raw_armap;
826     }
827
828   /* OK, build the carsyms.  */
829   for (i = 0; i < nsymz; i++)
830     {
831       rawptr = raw_armap + i;
832       carsyms->file_offset = swap ((bfd_byte *) rawptr);
833       carsyms->name = stringbase;
834       stringbase += strlen (stringbase) + 1;
835       carsyms++;
836     }
837   *stringbase = 0;
838
839   ardata->symdef_count = nsymz;
840   ardata->first_file_filepos = bfd_tell (abfd);
841   /* Pad to an even boundary if you have to.  */
842   ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
843
844   bfd_has_map (abfd) = TRUE;
845   bfd_release (abfd, raw_armap);
846
847   /* Check for a second archive header (as used by PE).  */
848   {
849     struct areltdata *tmp;
850
851     bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET);
852     tmp = _bfd_read_ar_hdr (abfd);
853     if (tmp != NULL)
854       {
855         if (tmp->arch_header[0] == '/'
856             && tmp->arch_header[1] == ' ')
857           {
858             ardata->first_file_filepos +=
859               (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1;
860           }
861         bfd_release (abfd, tmp);
862       }
863   }
864
865   return TRUE;
866
867 release_raw_armap:
868   bfd_release (abfd, raw_armap);
869 release_symdefs:
870   bfd_release (abfd, (ardata)->symdefs);
871   return FALSE;
872 }
873
874 /* This routine can handle either coff-style or bsd-style armaps.
875    Returns FALSE on error, TRUE otherwise */
876
877 bfd_boolean
878 bfd_slurp_armap (bfd *abfd)
879 {
880   char nextname[17];
881   int i = bfd_bread (nextname, 16, abfd);
882
883   if (i == 0)
884     return TRUE;
885   if (i != 16)
886     return FALSE;
887
888   if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
889     return FALSE;
890
891   if (!strncmp (nextname, "__.SYMDEF       ", 16)
892       || !strncmp (nextname, "__.SYMDEF/      ", 16)) /* old Linux archives */
893     return do_slurp_bsd_armap (abfd);
894   else if (!strncmp (nextname, "/               ", 16))
895     return do_slurp_coff_armap (abfd);
896   else if (!strncmp (nextname, "/SYM64/         ", 16))
897     {
898       /* 64bit ELF (Irix 6) archive.  */
899 #ifdef BFD64
900       extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *);
901       return bfd_elf64_archive_slurp_armap (abfd);
902 #else
903       bfd_set_error (bfd_error_wrong_format);
904       return FALSE;
905 #endif
906     }
907
908   bfd_has_map (abfd) = FALSE;
909   return TRUE;
910 }
911 \f
912 /* Returns FALSE on error, TRUE otherwise.  */
913 /* Flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
914    header is in a slightly different order and the map name is '/'.
915    This flavour is used by hp300hpux.  */
916
917 #define HPUX_SYMDEF_COUNT_SIZE 2
918
919 bfd_boolean
920 bfd_slurp_bsd_armap_f2 (bfd *abfd)
921 {
922   struct areltdata *mapdata;
923   char nextname[17];
924   unsigned int counter;
925   bfd_byte *raw_armap, *rbase;
926   struct artdata *ardata = bfd_ardata (abfd);
927   char *stringbase;
928   unsigned int stringsize;
929   bfd_size_type amt;
930   carsym *set;
931   int i = bfd_bread (nextname, 16, abfd);
932
933   if (i == 0)
934     return TRUE;
935   if (i != 16)
936     return FALSE;
937
938   /* The archive has at least 16 bytes in it.  */
939   if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
940     return FALSE;
941
942   if (!strncmp (nextname, "__.SYMDEF       ", 16)
943       || !strncmp (nextname, "__.SYMDEF/      ", 16)) /* Old Linux archives.  */
944     return do_slurp_bsd_armap (abfd);
945
946   if (strncmp (nextname, "/               ", 16))
947     {
948       bfd_has_map (abfd) = FALSE;
949       return TRUE;
950     }
951
952   mapdata = _bfd_read_ar_hdr (abfd);
953   if (mapdata == NULL)
954     return FALSE;
955
956   amt = mapdata->parsed_size;
957   raw_armap = bfd_zalloc (abfd, amt);
958   if (raw_armap == NULL)
959     {
960     byebye:
961       bfd_release (abfd, mapdata);
962       return FALSE;
963     }
964
965   if (bfd_bread (raw_armap, amt, abfd) != amt)
966     {
967       if (bfd_get_error () != bfd_error_system_call)
968         bfd_set_error (bfd_error_malformed_archive);
969     byebyebye:
970       bfd_release (abfd, raw_armap);
971       goto byebye;
972     }
973
974   ardata->symdef_count = H_GET_16 (abfd, raw_armap);
975
976   if (ardata->symdef_count * BSD_SYMDEF_SIZE
977       > mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE)
978     {
979       /* Probably we're using the wrong byte ordering.  */
980       bfd_set_error (bfd_error_wrong_format);
981       goto byebyebye;
982     }
983
984   ardata->cache = 0;
985
986   stringsize = H_GET_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE);
987   /* Skip sym count and string sz.  */
988   stringbase = ((char *) raw_armap
989                 + HPUX_SYMDEF_COUNT_SIZE
990                 + BSD_STRING_COUNT_SIZE);
991   rbase = (bfd_byte *) stringbase + stringsize;
992   amt = ardata->symdef_count * BSD_SYMDEF_SIZE;
993   ardata->symdefs = bfd_alloc (abfd, amt);
994   if (!ardata->symdefs)
995     return FALSE;
996
997   for (counter = 0, set = ardata->symdefs;
998        counter < ardata->symdef_count;
999        counter++, set++, rbase += BSD_SYMDEF_SIZE)
1000     {
1001       set->name = H_GET_32 (abfd, rbase) + stringbase;
1002       set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
1003     }
1004
1005   ardata->first_file_filepos = bfd_tell (abfd);
1006   /* Pad to an even boundary if you have to.  */
1007   ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1008   /* FIXME, we should provide some way to free raw_ardata when
1009      we are done using the strings from it.  For now, it seems
1010      to be allocated on an objalloc anyway...  */
1011   bfd_has_map (abfd) = TRUE;
1012   return TRUE;
1013 }
1014 \f
1015 /** Extended name table.
1016
1017   Normally archives support only 14-character filenames.
1018
1019   Intel has extended the format: longer names are stored in a special
1020   element (the first in the archive, or second if there is an armap);
1021   the name in the ar_hdr is replaced by <space><index into filename
1022   element>.  Index is the P.R. of an int (decimal).  Data General have
1023   extended the format by using the prefix // for the special element.  */
1024
1025 /* Returns FALSE on error, TRUE otherwise.  */
1026
1027 bfd_boolean
1028 _bfd_slurp_extended_name_table (bfd *abfd)
1029 {
1030   char nextname[17];
1031   struct areltdata *namedata;
1032   bfd_size_type amt;
1033
1034   /* FIXME:  Formatting sucks here, and in case of failure of BFD_READ,
1035      we probably don't want to return TRUE.  */
1036   bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET);
1037   if (bfd_bread (nextname, 16, abfd) == 16)
1038     {
1039       if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
1040         return FALSE;
1041
1042       if (strncmp (nextname, "ARFILENAMES/    ", 16) != 0 &&
1043           strncmp (nextname, "//              ", 16) != 0)
1044         {
1045           bfd_ardata (abfd)->extended_names = NULL;
1046           return TRUE;
1047         }
1048
1049       namedata = _bfd_read_ar_hdr (abfd);
1050       if (namedata == NULL)
1051         return FALSE;
1052
1053       amt = namedata->parsed_size;
1054       bfd_ardata (abfd)->extended_names = bfd_zalloc (abfd, amt);
1055       if (bfd_ardata (abfd)->extended_names == NULL)
1056         {
1057         byebye:
1058           bfd_release (abfd, namedata);
1059           return FALSE;
1060         }
1061
1062       if (bfd_bread (bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
1063         {
1064           if (bfd_get_error () != bfd_error_system_call)
1065             bfd_set_error (bfd_error_malformed_archive);
1066           bfd_release (abfd, (bfd_ardata (abfd)->extended_names));
1067           bfd_ardata (abfd)->extended_names = NULL;
1068           goto byebye;
1069         }
1070
1071       /* Since the archive is supposed to be printable if it contains
1072          text, the entries in the list are newline-padded, not null
1073          padded. In SVR4-style archives, the names also have a
1074          trailing '/'.  DOS/NT created archive often have \ in them
1075          We'll fix all problems here..  */
1076       {
1077         char *temp = bfd_ardata (abfd)->extended_names;
1078         char *limit = temp + namedata->parsed_size;
1079         for (; temp < limit; ++temp)
1080           {
1081             if (*temp == '\012')
1082               temp[temp[-1] == '/' ? -1 : 0] = '\0';
1083             if (*temp == '\\')
1084               *temp = '/';
1085           }
1086       }
1087
1088       /* Pad to an even boundary if you have to.  */
1089       bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd);
1090       bfd_ardata (abfd)->first_file_filepos +=
1091         (bfd_ardata (abfd)->first_file_filepos) % 2;
1092
1093       /* FIXME, we can't release namedata here because it was allocated
1094          below extended_names on the objalloc...  */
1095 #if 0
1096       bfd_release (abfd, namedata);
1097 #endif
1098     }
1099   return TRUE;
1100 }
1101
1102 #ifdef VMS
1103
1104 /* Return a copy of the stuff in the filename between any :]> and a
1105    semicolon.  */
1106
1107 static const char *
1108 normalize (bfd *abfd, const char *file)
1109 {
1110   const char *first;
1111   const char *last;
1112   char *copy;
1113
1114   first = file + strlen (file) - 1;
1115   last = first + 1;
1116
1117   while (first != file)
1118     {
1119       if (*first == ';')
1120         last = first;
1121       if (*first == ':' || *first == ']' || *first == '>')
1122         {
1123           first++;
1124           break;
1125         }
1126       first--;
1127     }
1128
1129   copy = bfd_alloc (abfd, last - first + 1);
1130   if (copy == NULL)
1131     return NULL;
1132
1133   memcpy (copy, first, last - first);
1134   copy[last - first] = 0;
1135
1136   return copy;
1137 }
1138
1139 #else
1140 static const char *
1141 normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file)
1142 {
1143   const char *filename = strrchr (file, '/');
1144
1145 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1146   {
1147     /* We could have foo/bar\\baz, or foo\\bar, or d:bar.  */
1148     char *bslash = strrchr (file, '\\');
1149     if (filename == NULL || (bslash != NULL && bslash > filename))
1150       filename = bslash;
1151     if (filename == NULL && file[0] != '\0' && file[1] == ':')
1152       filename = file + 1;
1153   }
1154 #endif
1155   if (filename != NULL)
1156     filename++;
1157   else
1158     filename = file;
1159   return filename;
1160 }
1161 #endif
1162
1163 /* Build a BFD style extended name table.  */
1164
1165 bfd_boolean
1166 _bfd_archive_bsd_construct_extended_name_table (bfd *abfd,
1167                                                 char **tabloc,
1168                                                 bfd_size_type *tablen,
1169                                                 const char **name)
1170 {
1171   *name = "ARFILENAMES/";
1172   return _bfd_construct_extended_name_table (abfd, FALSE, tabloc, tablen);
1173 }
1174
1175 /* Build an SVR4 style extended name table.  */
1176
1177 bfd_boolean
1178 _bfd_archive_coff_construct_extended_name_table (bfd *abfd,
1179                                                  char **tabloc,
1180                                                  bfd_size_type *tablen,
1181                                                  const char **name)
1182 {
1183   *name = "//";
1184   return _bfd_construct_extended_name_table (abfd, TRUE, tabloc, tablen);
1185 }
1186
1187 /* Follows archive_head and produces an extended name table if
1188    necessary.  Returns (in tabloc) a pointer to an extended name
1189    table, and in tablen the length of the table.  If it makes an entry
1190    it clobbers the filename so that the element may be written without
1191    further massage.  Returns TRUE if it ran successfully, FALSE if
1192    something went wrong.  A successful return may still involve a
1193    zero-length tablen!  */
1194
1195 bfd_boolean
1196 _bfd_construct_extended_name_table (bfd *abfd,
1197                                     bfd_boolean trailing_slash,
1198                                     char **tabloc,
1199                                     bfd_size_type *tablen)
1200 {
1201   unsigned int maxname = abfd->xvec->ar_max_namelen;
1202   bfd_size_type total_namelen = 0;
1203   bfd *current;
1204   char *strptr;
1205
1206   *tablen = 0;
1207
1208   /* Figure out how long the table should be.  */
1209   for (current = abfd->archive_head; current != NULL; current = current->next)
1210     {
1211       const char *normal;
1212       unsigned int thislen;
1213
1214       normal = normalize (current, current->filename);
1215       if (normal == NULL)
1216         return FALSE;
1217
1218       thislen = strlen (normal);
1219
1220       if (thislen > maxname
1221           && (bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1222         thislen = maxname;
1223
1224       if (thislen > maxname)
1225         {
1226           /* Add one to leave room for \n.  */
1227           total_namelen += thislen + 1;
1228           if (trailing_slash)
1229             {
1230               /* Leave room for trailing slash.  */
1231               ++total_namelen;
1232             }
1233         }
1234       else
1235         {
1236           struct ar_hdr *hdr = arch_hdr (current);
1237           if (strncmp (normal, hdr->ar_name, thislen) != 0
1238               || (thislen < sizeof hdr->ar_name
1239                   && hdr->ar_name[thislen] != ar_padchar (current)))
1240             {
1241               /* Must have been using extended format even though it
1242                  didn't need to.  Fix it to use normal format.  */
1243               memcpy (hdr->ar_name, normal, thislen);
1244               if (thislen < maxname
1245                   || (thislen == maxname && thislen < sizeof hdr->ar_name))
1246                 hdr->ar_name[thislen] = ar_padchar (current);
1247             }
1248         }
1249     }
1250
1251   if (total_namelen == 0)
1252     return TRUE;
1253
1254   *tabloc = bfd_zalloc (abfd, total_namelen);
1255   if (*tabloc == NULL)
1256     return FALSE;
1257
1258   *tablen = total_namelen;
1259   strptr = *tabloc;
1260
1261   for (current = abfd->archive_head; current != NULL; current =
1262        current->next)
1263     {
1264       const char *normal;
1265       unsigned int thislen;
1266
1267       normal = normalize (current, current->filename);
1268       if (normal == NULL)
1269         return FALSE;
1270
1271       thislen = strlen (normal);
1272       if (thislen > maxname)
1273         {
1274           /* Works for now; may need to be re-engineered if we
1275              encounter an oddball archive format and want to
1276              generalise this hack.  */
1277           struct ar_hdr *hdr = arch_hdr (current);
1278           strcpy (strptr, normal);
1279           if (! trailing_slash)
1280             strptr[thislen] = '\012';
1281           else
1282             {
1283               strptr[thislen] = '/';
1284               strptr[thislen + 1] = '\012';
1285             }
1286           hdr->ar_name[0] = ar_padchar (current);
1287           /* We know there will always be enough room (one of the few
1288              cases where you may safely use sprintf).  */
1289           sprintf ((hdr->ar_name) + 1, "%-d", (unsigned) (strptr - *tabloc));
1290           /* Kinda Kludgy.  We should just use the returned value of
1291              sprintf but not all implementations get this right.  */
1292           {
1293             char *temp = hdr->ar_name + 2;
1294             for (; temp < hdr->ar_name + maxname; temp++)
1295               if (*temp == '\0')
1296                 *temp = ' ';
1297           }
1298           strptr += thislen + 1;
1299           if (trailing_slash)
1300             ++strptr;
1301         }
1302     }
1303
1304   return TRUE;
1305 }
1306 \f
1307 /* A couple of functions for creating ar_hdrs.  */
1308
1309 #ifdef HPUX_LARGE_AR_IDS
1310 /* Function to encode large UID/GID values according to HP.  */
1311
1312 static void
1313 hpux_uid_gid_encode (char str[6], long int id)
1314 {
1315   int cnt;
1316
1317   str[5] = '@' + (id & 3);
1318   id >>= 2;
1319
1320   for (cnt = 4; cnt >= 0; ++cnt, id >>= 6)
1321     str[cnt] = ' ' + (id & 0x3f);
1322 }
1323 #endif  /* HPUX_LARGE_AR_IDS */
1324
1325 #ifndef HAVE_GETUID
1326 #define getuid() 0
1327 #endif
1328
1329 #ifndef HAVE_GETGID
1330 #define getgid() 0
1331 #endif
1332
1333 /* Takes a filename, returns an arelt_data for it, or NULL if it can't
1334    make one.  The filename must refer to a filename in the filesystem.
1335    The filename field of the ar_hdr will NOT be initialized.  If member
1336    is set, and it's an in-memory bfd, we fake it.  */
1337
1338 static struct areltdata *
1339 bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
1340 {
1341   struct stat status;
1342   struct areltdata *ared;
1343   struct ar_hdr *hdr;
1344   char *temp, *temp1;
1345   bfd_size_type amt;
1346
1347   if (member && (member->flags & BFD_IN_MEMORY) != 0)
1348     {
1349       /* Assume we just "made" the member, and fake it.  */
1350       struct bfd_in_memory *bim = member->iostream;
1351       time (&status.st_mtime);
1352       status.st_uid = getuid ();
1353       status.st_gid = getgid ();
1354       status.st_mode = 0644;
1355       status.st_size = bim->size;
1356     }
1357   else if (stat (filename, &status) != 0)
1358     {
1359       bfd_set_error (bfd_error_system_call);
1360       return NULL;
1361     }
1362
1363   amt = sizeof (struct ar_hdr) + sizeof (struct areltdata);
1364   ared = bfd_zalloc (abfd, amt);
1365   if (ared == NULL)
1366     return NULL;
1367   hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));
1368
1369   /* ar headers are space padded, not null padded!  */
1370   memset (hdr, ' ', sizeof (struct ar_hdr));
1371
1372   strncpy (hdr->ar_fmag, ARFMAG, 2);
1373
1374   /* Goddamned sprintf doesn't permit MAXIMUM field lengths.  */
1375   sprintf ((hdr->ar_date), "%-12ld", (long) status.st_mtime);
1376 #ifdef HPUX_LARGE_AR_IDS
1377   /* HP has a very "special" way to handle UID/GID's with numeric values
1378      > 99999.  */
1379   if (status.st_uid > 99999)
1380     hpux_uid_gid_encode (hdr->ar_gid, (long) status.st_uid);
1381   else
1382 #endif
1383     sprintf ((hdr->ar_uid), "%ld", (long) status.st_uid);
1384 #ifdef HPUX_LARGE_AR_IDS
1385   /* HP has a very "special" way to handle UID/GID's with numeric values
1386      > 99999.  */
1387   if (status.st_gid > 99999)
1388     hpux_uid_gid_encode (hdr->ar_uid, (long) status.st_gid);
1389   else
1390 #endif
1391   sprintf ((hdr->ar_gid), "%ld", (long) status.st_gid);
1392   sprintf ((hdr->ar_mode), "%-8o", (unsigned int) status.st_mode);
1393   sprintf ((hdr->ar_size), "%-10ld", (long) status.st_size);
1394   /* Correct for a lossage in sprintf whereby it null-terminates.  I cannot
1395      understand how these C losers could design such a ramshackle bunch of
1396      IO operations.  */
1397   temp = (char *) hdr;
1398   temp1 = temp + sizeof (struct ar_hdr) - 2;
1399   for (; temp < temp1; temp++)
1400     {
1401       if (*temp == '\0')
1402         *temp = ' ';
1403     }
1404   strncpy (hdr->ar_fmag, ARFMAG, 2);
1405   ared->parsed_size = status.st_size;
1406   ared->arch_header = (char *) hdr;
1407
1408   return ared;
1409 }
1410
1411 /* This is magic required by the "ar" program.  Since it's
1412    undocumented, it's undocumented.  You may think that it would take
1413    a strong stomach to write this, and it does, but it takes even a
1414    stronger stomach to try to code around such a thing!  */
1415
1416 struct ar_hdr *bfd_special_undocumented_glue (bfd *, const char *);
1417
1418 struct ar_hdr *
1419 bfd_special_undocumented_glue (bfd *abfd, const char *filename)
1420 {
1421   struct areltdata *ar_elt = bfd_ar_hdr_from_filesystem (abfd, filename, 0);
1422   if (ar_elt == NULL)
1423     return NULL;
1424   return (struct ar_hdr *) ar_elt->arch_header;
1425 }
1426
1427 /* Analogous to stat call.  */
1428
1429 int
1430 bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
1431 {
1432   struct ar_hdr *hdr;
1433   char *aloser;
1434
1435   if (abfd->arelt_data == NULL)
1436     {
1437       bfd_set_error (bfd_error_invalid_operation);
1438       return -1;
1439     }
1440
1441   hdr = arch_hdr (abfd);
1442
1443 #define foo(arelt, stelt, size)                         \
1444   buf->stelt = strtol (hdr->arelt, &aloser, size);      \
1445   if (aloser == hdr->arelt)                             \
1446     return -1;
1447
1448   /* Some platforms support special notations for large IDs.  */
1449 #ifdef HPUX_LARGE_AR_IDS
1450 # define foo2(arelt, stelt, size)                                       \
1451   if (hdr->arelt[5] == ' ')                                             \
1452     {                                                                   \
1453       foo (arelt, stelt, size);                                         \
1454     }                                                                   \
1455   else                                                                  \
1456     {                                                                   \
1457       int cnt;                                                          \
1458       for (buf->stelt = cnt = 0; cnt < 5; ++cnt)                        \
1459         {                                                               \
1460           if (hdr->arelt[cnt] < ' ' || hdr->arelt[cnt] > ' ' + 0x3f)    \
1461             return -1;                                                  \
1462           buf->stelt <<= 6;                                             \
1463           buf->stelt += hdr->arelt[cnt] - ' ';                          \
1464         }                                                               \
1465       if (hdr->arelt[5] < '@' || hdr->arelt[5] > '@' + 3)               \
1466         return -1;                                                      \
1467       buf->stelt <<= 2;                                                 \
1468       buf->stelt += hdr->arelt[5] - '@';                                \
1469     }
1470 #else
1471 # define foo2(arelt, stelt, size) foo (arelt, stelt, size)
1472 #endif
1473
1474   foo (ar_date, st_mtime, 10);
1475   foo2 (ar_uid, st_uid, 10);
1476   foo2 (ar_gid, st_gid, 10);
1477   foo (ar_mode, st_mode, 8);
1478
1479   buf->st_size = arch_eltdata (abfd)->parsed_size;
1480
1481   return 0;
1482 }
1483
1484 void
1485 bfd_dont_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1486 {
1487   /* FIXME: This interacts unpleasantly with ar's quick-append option.
1488      Fortunately ic960 users will never use that option.  Fixing this
1489      is very hard; fortunately I know how to do it and will do so once
1490      intel's release is out the door.  */
1491
1492   struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1493   size_t length;
1494   const char *filename;
1495   size_t maxlen = ar_maxnamelen (abfd);
1496
1497   if ((bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1498     {
1499       bfd_bsd_truncate_arname (abfd, pathname, arhdr);
1500       return;
1501     }
1502
1503   filename = normalize (abfd, pathname);
1504   if (filename == NULL)
1505     {
1506       /* FIXME */
1507       abort ();
1508     }
1509
1510   length = strlen (filename);
1511
1512   if (length <= maxlen)
1513     memcpy (hdr->ar_name, filename, length);
1514
1515   /* Add the padding character if there is room for it.  */
1516   if (length < maxlen
1517       || (length == maxlen && length < sizeof hdr->ar_name))
1518     (hdr->ar_name)[length] = ar_padchar (abfd);
1519 }
1520
1521 void
1522 bfd_bsd_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1523 {
1524   struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1525   size_t length;
1526   const char *filename = strrchr (pathname, '/');
1527   size_t maxlen = ar_maxnamelen (abfd);
1528
1529 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1530   {
1531     /* We could have foo/bar\\baz, or foo\\bar, or d:bar.  */
1532     char *bslash = strrchr (pathname, '\\');
1533     if (filename == NULL || (bslash != NULL && bslash > filename))
1534       filename = bslash;
1535     if (filename == NULL && pathname[0] != '\0' && pathname[1] == ':')
1536       filename = pathname + 1;
1537   }
1538 #endif
1539
1540   if (filename == NULL)
1541     filename = pathname;
1542   else
1543     ++filename;
1544
1545   length = strlen (filename);
1546
1547   if (length <= maxlen)
1548     memcpy (hdr->ar_name, filename, length);
1549   else
1550     {
1551       /* pathname: meet procrustes */
1552       memcpy (hdr->ar_name, filename, maxlen);
1553       length = maxlen;
1554     }
1555
1556   if (length < maxlen)
1557     (hdr->ar_name)[length] = ar_padchar (abfd);
1558 }
1559
1560 /* Store name into ar header.  Truncates the name to fit.
1561    1> strip pathname to be just the basename.
1562    2> if it's short enuf to fit, stuff it in.
1563    3> If it doesn't end with .o, truncate it to fit
1564    4> truncate it before the .o, append .o, stuff THAT in.  */
1565
1566 /* This is what gnu ar does.  It's better but incompatible with the
1567    bsd ar.  */
1568
1569 void
1570 bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
1571 {
1572   struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
1573   size_t length;
1574   const char *filename = strrchr (pathname, '/');
1575   size_t maxlen = ar_maxnamelen (abfd);
1576
1577 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1578   {
1579     /* We could have foo/bar\\baz, or foo\\bar, or d:bar.  */
1580     char *bslash = strrchr (pathname, '\\');
1581     if (filename == NULL || (bslash != NULL && bslash > filename))
1582       filename = bslash;
1583     if (filename == NULL && pathname[0] != '\0' && pathname[1] == ':')
1584       filename = pathname + 1;
1585   }
1586 #endif
1587
1588   if (filename == NULL)
1589     filename = pathname;
1590   else
1591     ++filename;
1592
1593   length = strlen (filename);
1594
1595   if (length <= maxlen)
1596     memcpy (hdr->ar_name, filename, length);
1597   else
1598     {                           /* pathname: meet procrustes */
1599       memcpy (hdr->ar_name, filename, maxlen);
1600       if ((filename[length - 2] == '.') && (filename[length - 1] == 'o'))
1601         {
1602           hdr->ar_name[maxlen - 2] = '.';
1603           hdr->ar_name[maxlen - 1] = 'o';
1604         }
1605       length = maxlen;
1606     }
1607
1608   if (length < 16)
1609     (hdr->ar_name)[length] = ar_padchar (abfd);
1610 }
1611 \f
1612 /* The BFD is open for write and has its format set to bfd_archive.  */
1613
1614 bfd_boolean
1615 _bfd_write_archive_contents (bfd *arch)
1616 {
1617   bfd *current;
1618   char *etable = NULL;
1619   bfd_size_type elength = 0;
1620   const char *ename = NULL;
1621   bfd_boolean makemap = bfd_has_map (arch);
1622   /* If no .o's, don't bother to make a map.  */
1623   bfd_boolean hasobjects = FALSE;
1624   bfd_size_type wrote;
1625   unsigned int i;
1626   int tries;
1627
1628   /* Verify the viability of all entries; if any of them live in the
1629      filesystem (as opposed to living in an archive open for input)
1630      then construct a fresh ar_hdr for them.  */
1631   for (current = arch->archive_head; current; current = current->next)
1632     {
1633       /* This check is checking the bfds for the objects we're reading
1634          from (which are usually either an object file or archive on
1635          disk), not the archive entries we're writing to.  We don't
1636          actually create bfds for the archive members, we just copy
1637          them byte-wise when we write out the archive.  */
1638       if (bfd_write_p (current))
1639         {
1640           bfd_set_error (bfd_error_invalid_operation);
1641           return FALSE;
1642         }
1643       if (!current->arelt_data)
1644         {
1645           current->arelt_data =
1646             bfd_ar_hdr_from_filesystem (arch, current->filename, current);
1647           if (!current->arelt_data)
1648             return FALSE;
1649
1650           /* Put in the file name.  */
1651           BFD_SEND (arch, _bfd_truncate_arname,
1652                     (arch, current->filename, (char *) arch_hdr (current)));
1653         }
1654
1655       if (makemap && ! hasobjects)
1656         {                       /* Don't bother if we won't make a map!  */
1657           if ((bfd_check_format (current, bfd_object))
1658 #if 0                           /* FIXME -- these are not set correctly */
1659               && ((bfd_get_file_flags (current) & HAS_SYMS))
1660 #endif
1661             )
1662             hasobjects = TRUE;
1663         }
1664     }
1665
1666   if (!BFD_SEND (arch, _bfd_construct_extended_name_table,
1667                  (arch, &etable, &elength, &ename)))
1668     return FALSE;
1669
1670   if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0)
1671     return FALSE;
1672 #ifdef GNU960
1673   wrote = bfd_bwrite (BFD_GNU960_ARMAG (arch), SARMAG, arch);
1674 #else
1675   wrote = bfd_bwrite (ARMAG, SARMAG, arch);
1676 #endif
1677   if (wrote != SARMAG)
1678     return FALSE;
1679
1680   if (makemap && hasobjects)
1681     {
1682       if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength))
1683         return FALSE;
1684     }
1685
1686   if (elength != 0)
1687     {
1688       struct ar_hdr hdr;
1689
1690       memset (&hdr, 0, sizeof (struct ar_hdr));
1691       strcpy (hdr.ar_name, ename);
1692       /* Round size up to even number in archive header.  */
1693       sprintf (&(hdr.ar_size[0]), "%-10d",
1694                (int) ((elength + 1) & ~(bfd_size_type) 1));
1695       strncpy (hdr.ar_fmag, ARFMAG, 2);
1696       for (i = 0; i < sizeof (struct ar_hdr); i++)
1697         if (((char *) (&hdr))[i] == '\0')
1698           (((char *) (&hdr))[i]) = ' ';
1699       if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
1700            != sizeof (struct ar_hdr))
1701           || bfd_bwrite (etable, elength, arch) != elength)
1702         return FALSE;
1703       if ((elength % 2) == 1)
1704         {
1705           if (bfd_bwrite ("\012", 1, arch) != 1)
1706             return FALSE;
1707         }
1708     }
1709
1710   for (current = arch->archive_head; current; current = current->next)
1711     {
1712       char buffer[DEFAULT_BUFFERSIZE];
1713       unsigned int remaining = arelt_size (current);
1714       struct ar_hdr *hdr = arch_hdr (current);
1715
1716       /* Write ar header.  */
1717       if (bfd_bwrite (hdr, sizeof (*hdr), arch)
1718           != sizeof (*hdr))
1719         return FALSE;
1720       if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
1721         return FALSE;
1722       while (remaining)
1723         {
1724           unsigned int amt = DEFAULT_BUFFERSIZE;
1725           if (amt > remaining)
1726             amt = remaining;
1727           errno = 0;
1728           if (bfd_bread (buffer, amt, current) != amt)
1729             {
1730               if (bfd_get_error () != bfd_error_system_call)
1731                 bfd_set_error (bfd_error_malformed_archive);
1732               return FALSE;
1733             }
1734           if (bfd_bwrite (buffer, amt, arch) != amt)
1735             return FALSE;
1736           remaining -= amt;
1737         }
1738       if ((arelt_size (current) % 2) == 1)
1739         {
1740           if (bfd_bwrite ("\012", 1, arch) != 1)
1741             return FALSE;
1742         }
1743     }
1744
1745   if (makemap && hasobjects)
1746     {
1747       /* Verify the timestamp in the archive file.  If it would not be
1748          accepted by the linker, rewrite it until it would be.  If
1749          anything odd happens, break out and just return.  (The
1750          Berkeley linker checks the timestamp and refuses to read the
1751          table-of-contents if it is >60 seconds less than the file's
1752          modified-time.  That painful hack requires this painful hack.  */
1753       tries = 1;
1754       do
1755         {
1756           if (bfd_update_armap_timestamp (arch))
1757             break;
1758           (*_bfd_error_handler)
1759             (_("Warning: writing archive was slow: rewriting timestamp\n"));
1760         }
1761       while (++tries < 6);
1762     }
1763
1764   return TRUE;
1765 }
1766 \f
1767 /* Note that the namidx for the first symbol is 0.  */
1768
1769 bfd_boolean
1770 _bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
1771 {
1772   char *first_name = NULL;
1773   bfd *current;
1774   file_ptr elt_no = 0;
1775   struct orl *map = NULL;
1776   unsigned int orl_max = 1024;          /* Fine initial default.  */
1777   unsigned int orl_count = 0;
1778   int stridx = 0;
1779   asymbol **syms = NULL;
1780   long syms_max = 0;
1781   bfd_boolean ret;
1782   bfd_size_type amt;
1783
1784   /* Dunno if this is the best place for this info...  */
1785   if (elength != 0)
1786     elength += sizeof (struct ar_hdr);
1787   elength += elength % 2;
1788
1789   amt = orl_max * sizeof (struct orl);
1790   map = bfd_malloc (amt);
1791   if (map == NULL)
1792     goto error_return;
1793
1794   /* We put the symbol names on the arch objalloc, and then discard
1795      them when done.  */
1796   first_name = bfd_alloc (arch, 1);
1797   if (first_name == NULL)
1798     goto error_return;
1799
1800   /* Drop all the files called __.SYMDEF, we're going to make our own.  */
1801   while (arch->archive_head &&
1802          strcmp (arch->archive_head->filename, "__.SYMDEF") == 0)
1803     arch->archive_head = arch->archive_head->next;
1804
1805   /* Map over each element.  */
1806   for (current = arch->archive_head;
1807        current != NULL;
1808        current = current->next, elt_no++)
1809     {
1810       if (bfd_check_format (current, bfd_object)
1811           && (bfd_get_file_flags (current) & HAS_SYMS) != 0)
1812         {
1813           long storage;
1814           long symcount;
1815           long src_count;
1816
1817           storage = bfd_get_symtab_upper_bound (current);
1818           if (storage < 0)
1819             goto error_return;
1820
1821           if (storage != 0)
1822             {
1823               if (storage > syms_max)
1824                 {
1825                   if (syms_max > 0)
1826                     free (syms);
1827                   syms_max = storage;
1828                   syms = bfd_malloc (syms_max);
1829                   if (syms == NULL)
1830                     goto error_return;
1831                 }
1832               symcount = bfd_canonicalize_symtab (current, syms);
1833               if (symcount < 0)
1834                 goto error_return;
1835
1836               /* Now map over all the symbols, picking out the ones we
1837                  want.  */
1838               for (src_count = 0; src_count < symcount; src_count++)
1839                 {
1840                   flagword flags = (syms[src_count])->flags;
1841                   asection *sec = syms[src_count]->section;
1842
1843                   if ((flags & BSF_GLOBAL ||
1844                        flags & BSF_WEAK ||
1845                        flags & BSF_INDIRECT ||
1846                        bfd_is_com_section (sec))
1847                       && ! bfd_is_und_section (sec))
1848                     {
1849                       bfd_size_type namelen;
1850                       struct orl *new_map;
1851
1852                       /* This symbol will go into the archive header.  */
1853                       if (orl_count == orl_max)
1854                         {
1855                           orl_max *= 2;
1856                           amt = orl_max * sizeof (struct orl);
1857                           new_map = bfd_realloc (map, amt);
1858                           if (new_map == NULL)
1859                             goto error_return;
1860
1861                           map = new_map;
1862                         }
1863
1864                       namelen = strlen (syms[src_count]->name);
1865                       amt = sizeof (char *);
1866                       map[orl_count].name = bfd_alloc (arch, amt);
1867                       if (map[orl_count].name == NULL)
1868                         goto error_return;
1869                       *(map[orl_count].name) = bfd_alloc (arch, namelen + 1);
1870                       if (*(map[orl_count].name) == NULL)
1871                         goto error_return;
1872                       strcpy (*(map[orl_count].name), syms[src_count]->name);
1873                       map[orl_count].u.abfd = current;
1874                       map[orl_count].namidx = stridx;
1875
1876                       stridx += namelen + 1;
1877                       ++orl_count;
1878                     }
1879                 }
1880             }
1881
1882           /* Now ask the BFD to free up any cached information, so we
1883              don't fill all of memory with symbol tables.  */
1884           if (! bfd_free_cached_info (current))
1885             goto error_return;
1886         }
1887     }
1888
1889   /* OK, now we have collected all the data, let's write them out.  */
1890   ret = BFD_SEND (arch, write_armap,
1891                   (arch, elength, map, orl_count, stridx));
1892
1893   if (syms_max > 0)
1894     free (syms);
1895   if (map != NULL)
1896     free (map);
1897   if (first_name != NULL)
1898     bfd_release (arch, first_name);
1899
1900   return ret;
1901
1902  error_return:
1903   if (syms_max > 0)
1904     free (syms);
1905   if (map != NULL)
1906     free (map);
1907   if (first_name != NULL)
1908     bfd_release (arch, first_name);
1909
1910   return FALSE;
1911 }
1912
1913 bfd_boolean
1914 bsd_write_armap (bfd *arch,
1915                  unsigned int elength,
1916                  struct orl *map,
1917                  unsigned int orl_count,
1918                  int stridx)
1919 {
1920   int padit = stridx & 1;
1921   unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE;
1922   unsigned int stringsize = stridx + padit;
1923   /* Include 8 bytes to store ranlibsize and stringsize in output.  */
1924   unsigned int mapsize = ranlibsize + stringsize + 8;
1925   file_ptr firstreal;
1926   bfd *current = arch->archive_head;
1927   bfd *last_elt = current;      /* Last element arch seen.  */
1928   bfd_byte temp[4];
1929   unsigned int count;
1930   struct ar_hdr hdr;
1931   struct stat statbuf;
1932   unsigned int i;
1933
1934   firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
1935
1936   stat (arch->filename, &statbuf);
1937   memset (&hdr, 0, sizeof (struct ar_hdr));
1938   sprintf (hdr.ar_name, RANLIBMAG);
1939   /* Remember the timestamp, to keep it holy.  But fudge it a little.  */
1940   bfd_ardata (arch)->armap_timestamp = statbuf.st_mtime + ARMAP_TIME_OFFSET;
1941   bfd_ardata (arch)->armap_datepos = (SARMAG
1942                                       + offsetof (struct ar_hdr, ar_date[0]));
1943   sprintf (hdr.ar_date, "%ld", bfd_ardata (arch)->armap_timestamp);
1944   sprintf (hdr.ar_uid, "%ld", (long) getuid ());
1945   sprintf (hdr.ar_gid, "%ld", (long) getgid ());
1946   sprintf (hdr.ar_size, "%-10d", (int) mapsize);
1947   strncpy (hdr.ar_fmag, ARFMAG, 2);
1948   for (i = 0; i < sizeof (struct ar_hdr); i++)
1949     if (((char *) (&hdr))[i] == '\0')
1950       (((char *) (&hdr))[i]) = ' ';
1951   if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
1952       != sizeof (struct ar_hdr))
1953     return FALSE;
1954   H_PUT_32 (arch, ranlibsize, temp);
1955   if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
1956     return FALSE;
1957
1958   for (count = 0; count < orl_count; count++)
1959     {
1960       bfd_byte buf[BSD_SYMDEF_SIZE];
1961
1962       if (map[count].u.abfd != last_elt)
1963         {
1964           do
1965             {
1966               firstreal += arelt_size (current) + sizeof (struct ar_hdr);
1967               firstreal += firstreal % 2;
1968               current = current->next;
1969             }
1970           while (current != map[count].u.abfd);
1971         }
1972
1973       last_elt = current;
1974       H_PUT_32 (arch, map[count].namidx, buf);
1975       H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE);
1976       if (bfd_bwrite (buf, BSD_SYMDEF_SIZE, arch)
1977           != BSD_SYMDEF_SIZE)
1978         return FALSE;
1979     }
1980
1981   /* Now write the strings themselves.  */
1982   H_PUT_32 (arch, stringsize, temp);
1983   if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
1984     return FALSE;
1985   for (count = 0; count < orl_count; count++)
1986     {
1987       size_t len = strlen (*map[count].name) + 1;
1988
1989       if (bfd_bwrite (*map[count].name, len, arch) != len)
1990         return FALSE;
1991     }
1992
1993   /* The spec sez this should be a newline.  But in order to be
1994      bug-compatible for sun's ar we use a null.  */
1995   if (padit)
1996     {
1997       if (bfd_bwrite ("", 1, arch) != 1)
1998         return FALSE;
1999     }
2000
2001   return TRUE;
2002 }
2003
2004 /* At the end of archive file handling, update the timestamp in the
2005    file, so the linker will accept it.
2006
2007    Return TRUE if the timestamp was OK, or an unusual problem happened.
2008    Return FALSE if we updated the timestamp.  */
2009
2010 bfd_boolean
2011 _bfd_archive_bsd_update_armap_timestamp (bfd *arch)
2012 {
2013   struct stat archstat;
2014   struct ar_hdr hdr;
2015   unsigned int i;
2016
2017   /* Flush writes, get last-write timestamp from file, and compare it
2018      to the timestamp IN the file.  */
2019   bfd_flush (arch);
2020   if (bfd_stat (arch, &archstat) == -1)
2021     {
2022       bfd_perror (_("Reading archive file mod timestamp"));
2023
2024       /* Can't read mod time for some reason.  */
2025       return TRUE;
2026     }
2027   if (archstat.st_mtime <= bfd_ardata (arch)->armap_timestamp)
2028     /* OK by the linker's rules.  */
2029     return TRUE;
2030
2031   /* Update the timestamp.  */
2032   bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET;
2033
2034   /* Prepare an ASCII version suitable for writing.  */
2035   memset (hdr.ar_date, 0, sizeof (hdr.ar_date));
2036   sprintf (hdr.ar_date, "%ld", bfd_ardata (arch)->armap_timestamp);
2037   for (i = 0; i < sizeof (hdr.ar_date); i++)
2038     if (hdr.ar_date[i] == '\0')
2039       (hdr.ar_date)[i] = ' ';
2040
2041   /* Write it into the file.  */
2042   bfd_ardata (arch)->armap_datepos = (SARMAG
2043                                       + offsetof (struct ar_hdr, ar_date[0]));
2044   if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0
2045       || (bfd_bwrite (hdr.ar_date, sizeof (hdr.ar_date), arch)
2046           != sizeof (hdr.ar_date)))
2047     {
2048       bfd_perror (_("Writing updated armap timestamp"));
2049
2050       /* Some error while writing.  */
2051       return TRUE;
2052     }
2053
2054   /* We updated the timestamp successfully.  */
2055   return FALSE;
2056 }
2057 \f
2058 /* A coff armap looks like :
2059    lARMAG
2060    struct ar_hdr with name = '/'
2061    number of symbols
2062    offset of file for symbol 0
2063    offset of file for symbol 1
2064
2065    offset of file for symbol n-1
2066    symbol name 0
2067    symbol name 1
2068
2069    symbol name n-1  */
2070
2071 bfd_boolean
2072 coff_write_armap (bfd *arch,
2073                   unsigned int elength,
2074                   struct orl *map,
2075                   unsigned int symbol_count,
2076                   int stridx)
2077 {
2078   /* The size of the ranlib is the number of exported symbols in the
2079      archive * the number of bytes in an int, + an int for the count.  */
2080   unsigned int ranlibsize = (symbol_count * 4) + 4;
2081   unsigned int stringsize = stridx;
2082   unsigned int mapsize = stringsize + ranlibsize;
2083   unsigned int archive_member_file_ptr;
2084   bfd *current = arch->archive_head;
2085   unsigned int count;
2086   struct ar_hdr hdr;
2087   unsigned int i;
2088   int padit = mapsize & 1;
2089
2090   if (padit)
2091     mapsize++;
2092
2093   /* Work out where the first object file will go in the archive.  */
2094   archive_member_file_ptr = (mapsize
2095                              + elength
2096                              + sizeof (struct ar_hdr)
2097                              + SARMAG);
2098
2099   memset (&hdr, 0, sizeof (struct ar_hdr));
2100   hdr.ar_name[0] = '/';
2101   sprintf (hdr.ar_size, "%-10d", (int) mapsize);
2102   sprintf (hdr.ar_date, "%ld", (long) time (NULL));
2103   /* This, at least, is what Intel coff sets the values to.  */
2104   sprintf ((hdr.ar_uid), "%d", 0);
2105   sprintf ((hdr.ar_gid), "%d", 0);
2106   sprintf ((hdr.ar_mode), "%-7o", (unsigned) 0);
2107   strncpy (hdr.ar_fmag, ARFMAG, 2);
2108
2109   for (i = 0; i < sizeof (struct ar_hdr); i++)
2110     if (((char *) (&hdr))[i] == '\0')
2111       (((char *) (&hdr))[i]) = ' ';
2112
2113   /* Write the ar header for this item and the number of symbols.  */
2114   if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
2115       != sizeof (struct ar_hdr))
2116     return FALSE;
2117
2118   if (!bfd_write_bigendian_4byte_int (arch, symbol_count))
2119     return FALSE;
2120
2121   /* Two passes, first write the file offsets for each symbol -
2122      remembering that each offset is on a two byte boundary.  */
2123
2124   /* Write out the file offset for the file associated with each
2125      symbol, and remember to keep the offsets padded out.  */
2126
2127   current = arch->archive_head;
2128   count = 0;
2129   while (current != NULL && count < symbol_count)
2130     {
2131       /* For each symbol which is used defined in this object, write
2132          out the object file's address in the archive.  */
2133
2134       while (count < symbol_count && map[count].u.abfd == current)
2135         {
2136           if (!bfd_write_bigendian_4byte_int (arch, archive_member_file_ptr))
2137             return FALSE;
2138           count++;
2139         }
2140       /* Add size of this archive entry.  */
2141       archive_member_file_ptr += arelt_size (current) + sizeof (struct ar_hdr);
2142       /* Remember aboout the even alignment.  */
2143       archive_member_file_ptr += archive_member_file_ptr % 2;
2144       current = current->next;
2145     }
2146
2147   /* Now write the strings themselves.  */
2148   for (count = 0; count < symbol_count; count++)
2149     {
2150       size_t len = strlen (*map[count].name) + 1;
2151
2152       if (bfd_bwrite (*map[count].name, len, arch) != len)
2153         return FALSE;
2154     }
2155
2156   /* The spec sez this should be a newline.  But in order to be
2157      bug-compatible for arc960 we use a null.  */
2158   if (padit)
2159     {
2160       if (bfd_bwrite ("", 1, arch) != 1)
2161         return FALSE;
2162     }
2163
2164   return TRUE;
2165 }