daily update
[binutils.git] / bfd / archive.c
CommitLineData
252b5132 1/* BFD back-end for archive files (libraries).
7898deda 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
f1bb16f8
NC
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
4 2012 Free Software Foundation, Inc.
252b5132
RH
5 Written by Cygnus Support. Mostly Gumby Henkel-Wallace's fault.
6
1b09e940 7 This file is part of BFD, the Binary File Descriptor library.
252b5132 8
1b09e940
NC
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
cd123cb7 11 the Free Software Foundation; either version 3 of the License, or
1b09e940 12 (at your option) any later version.
252b5132 13
1b09e940
NC
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.
252b5132 18
1b09e940
NC
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
3e110533 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
252b5132
RH
22
23/*
24@setfilename archive-info
25SECTION
26 Archives
27
28DESCRIPTION
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
1b74d094
BW
77SUBSECTION
78 Archive functions
252b5132
RH
79*/
80
81/* Assumes:
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).
85*/
86
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.
95
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.
99
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.
104
105 BSD 4.4 uses a third scheme: It writes a long filename
106 directly after the header. This allows 'ar q' to work.
252b5132
RH
107*/
108
109/* Summary of archive member names:
110
111 Symbol table (must be first):
112 "__.SYMDEF " - Symbol table, Berkeley style, produced by ranlib.
113 "/ " - Symbol table, system 5 style.
114
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).
118
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).
122
123 Regular files with long names (or embedded spaces, for BSD variants):
124 "/18 " - SVR4 style, name at offset 18 in name table.
390c0e42 125 "#1/23 " - Long name (or embedded spaces) 23 characters long,
252b5132 126 BSD 4.4 style, full name follows header.
252b5132
RH
127 " 18 " - Long name 18 characters long, extended pseudo-BSD.
128 */
129
252b5132 130#include "sysdep.h"
3db64b00 131#include "bfd.h"
b820f1e4 132#include "libiberty.h"
252b5132
RH
133#include "libbfd.h"
134#include "aout/ar.h"
135#include "aout/ranlib.h"
3882b010 136#include "safe-ctype.h"
109f7096 137#include "hashtab.h"
a8da6403 138#include "filenames.h"
252b5132
RH
139
140#ifndef errno
141extern int errno;
142#endif
143
252b5132
RH
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
047066e1 149 to the front of the contents! */
2c3fc389
NC
150struct ar_cache
151{
252b5132 152 file_ptr ptr;
109f7096 153 bfd *arbfd;
252b5132
RH
154};
155
156#define ar_padchar(abfd) ((abfd)->xvec->ar_pad_char)
157#define ar_maxnamelen(abfd) ((abfd)->xvec->ar_max_namelen)
158
beb0d161 159#define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data))
a8da6403 160#define arch_hdr(bfd) ((struct ar_hdr *) arch_eltdata (bfd)->arch_header)
8f95b6e4
TG
161
162/* True iff NAME designated a BSD 4.4 extended name. */
163
164#define is_bsd44_extended_name(NAME) \
165 (NAME[0] == '#' && NAME[1] == '1' && NAME[2] == '/' && ISDIGIT (NAME[3]))
390c0e42
JJ
166\f
167void
168_bfd_ar_spacepad (char *p, size_t n, const char *fmt, long val)
169{
170 static char buf[20];
171 size_t len;
2c3fc389 172
390c0e42
JJ
173 snprintf (buf, sizeof (buf), fmt, val);
174 len = strlen (buf);
175 if (len < n)
176 {
177 memcpy (p, buf, len);
178 memset (p + len, ' ', n - len);
179 }
180 else
181 memcpy (p, buf, n);
182}
f1bb16f8
NC
183
184bfd_boolean
185_bfd_ar_sizepad (char *p, size_t n, bfd_size_type size)
186{
187 static char buf[21];
188 size_t len;
189
190 snprintf (buf, sizeof (buf), "%-10" BFD_VMA_FMT "u", size);
191 len = strlen (buf);
192 if (len > n)
193 {
194 bfd_set_error (bfd_error_file_too_big);
195 return FALSE;
196 }
197 if (len < n)
198 {
199 memcpy (p, buf, len);
200 memset (p + len, ' ', n - len);
201 }
202 else
203 memcpy (p, buf, n);
204 return TRUE;
205}
252b5132 206\f
b34976b6 207bfd_boolean
c58b9523 208_bfd_generic_mkarchive (bfd *abfd)
252b5132 209{
dc810e39 210 bfd_size_type amt = sizeof (struct artdata);
252b5132 211
a50b1753 212 abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc (abfd, amt);
252b5132 213 if (bfd_ardata (abfd) == NULL)
b34976b6 214 return FALSE;
252b5132 215
9e492e05
JJ
216 /* Already cleared by bfd_zalloc above.
217 bfd_ardata (abfd)->cache = NULL;
218 bfd_ardata (abfd)->archive_head = NULL;
219 bfd_ardata (abfd)->symdefs = NULL;
220 bfd_ardata (abfd)->extended_names = NULL;
221 bfd_ardata (abfd)->extended_names_size = 0;
222 bfd_ardata (abfd)->tdata = NULL; */
252b5132 223
b34976b6 224 return TRUE;
252b5132
RH
225}
226
227/*
228FUNCTION
229 bfd_get_next_mapent
230
231SYNOPSIS
c58b9523
AM
232 symindex bfd_get_next_mapent
233 (bfd *abfd, symindex previous, carsym **sym);
252b5132
RH
234
235DESCRIPTION
236 Step through archive @var{abfd}'s symbol table (if it
237 has one). Successively update @var{sym} with the next symbol's
238 information, returning that symbol's (internal) index into the
239 symbol table.
240
241 Supply <<BFD_NO_MORE_SYMBOLS>> as the @var{previous} entry to get
242 the first one; returns <<BFD_NO_MORE_SYMBOLS>> when you've already
243 got the last one.
244
245 A <<carsym>> is a canonical archive symbol. The only
246 user-visible element is its name, a null-terminated string.
247*/
248
249symindex
c58b9523 250bfd_get_next_mapent (bfd *abfd, symindex prev, carsym **entry)
252b5132
RH
251{
252 if (!bfd_has_map (abfd))
253 {
254 bfd_set_error (bfd_error_invalid_operation);
255 return BFD_NO_MORE_SYMBOLS;
256 }
257
258 if (prev == BFD_NO_MORE_SYMBOLS)
259 prev = 0;
260 else
261 ++prev;
262 if (prev >= bfd_ardata (abfd)->symdef_count)
263 return BFD_NO_MORE_SYMBOLS;
264
265 *entry = (bfd_ardata (abfd)->symdefs + prev);
266 return prev;
267}
268
06fc8a8c 269/* To be called by backends only. */
252b5132
RH
270
271bfd *
c58b9523 272_bfd_create_empty_archive_element_shell (bfd *obfd)
252b5132
RH
273{
274 return _bfd_new_bfd_contained_in (obfd);
275}
276
277/*
278FUNCTION
279 bfd_set_archive_head
280
281SYNOPSIS
c58b9523 282 bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);
252b5132
RH
283
284DESCRIPTION
285 Set the head of the chain of
286 BFDs contained in the archive @var{output} to @var{new_head}.
287*/
288
b34976b6 289bfd_boolean
c58b9523 290bfd_set_archive_head (bfd *output_archive, bfd *new_head)
252b5132 291{
252b5132 292 output_archive->archive_head = new_head;
b34976b6 293 return TRUE;
252b5132
RH
294}
295
a988325c
NC
296/* Free the archive hash table, if it exists. */
297
298void
299_bfd_delete_archive_data (bfd *abfd)
300{
301 struct artdata *ardata = bfd_ardata (abfd);
302
303 BFD_ASSERT (abfd->format == bfd_archive);
304
305 if (ardata && ardata->cache)
306 htab_delete (ardata->cache);
307}
308
252b5132 309bfd *
c58b9523 310_bfd_look_for_bfd_in_cache (bfd *arch_bfd, file_ptr filepos)
252b5132 311{
a2633f4e 312 htab_t hash_table = bfd_ardata (arch_bfd)->cache;
109f7096 313 struct ar_cache m;
2c3fc389 314
109f7096 315 m.ptr = filepos;
252b5132 316
109f7096
BE
317 if (hash_table)
318 {
319 struct ar_cache *entry = (struct ar_cache *) htab_find (hash_table, &m);
320 if (!entry)
321 return NULL;
322 else
323 return entry->arbfd;
324 }
325 else
326 return NULL;
327}
328
329static hashval_t
2c3fc389 330hash_file_ptr (const void * p)
109f7096
BE
331{
332 return (hashval_t) (((struct ar_cache *) p)->ptr);
333}
252b5132 334
109f7096
BE
335/* Returns non-zero if P1 and P2 are equal. */
336
337static int
2c3fc389 338eq_file_ptr (const void * p1, const void * p2)
109f7096
BE
339{
340 struct ar_cache *arc1 = (struct ar_cache *) p1;
341 struct ar_cache *arc2 = (struct ar_cache *) p2;
342 return arc1->ptr == arc2->ptr;
252b5132
RH
343}
344
9fcd9da6
NC
345/* The calloc function doesn't always take size_t (e.g. on VMS)
346 so wrap it to avoid a compile time warning. */
347
348static void *
349_bfd_calloc_wrapper (size_t a, size_t b)
350{
351 return calloc (a, b);
352}
353
06fc8a8c
NC
354/* Kind of stupid to call cons for each one, but we don't do too many. */
355
b34976b6 356bfd_boolean
c58b9523 357_bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt)
252b5132 358{
109f7096
BE
359 struct ar_cache *cache;
360 htab_t hash_table = bfd_ardata (arch_bfd)->cache;
252b5132 361
109f7096
BE
362 /* If the hash table hasn't been created, create it. */
363 if (hash_table == NULL)
252b5132 364 {
109f7096 365 hash_table = htab_create_alloc (16, hash_file_ptr, eq_file_ptr,
9fcd9da6 366 NULL, _bfd_calloc_wrapper, free);
109f7096
BE
367 if (hash_table == NULL)
368 return FALSE;
369 bfd_ardata (arch_bfd)->cache = hash_table;
252b5132
RH
370 }
371
109f7096 372 /* Insert new_elt into the hash table by filepos. */
a50b1753 373 cache = (struct ar_cache *) bfd_zalloc (arch_bfd, sizeof (struct ar_cache));
109f7096
BE
374 cache->ptr = filepos;
375 cache->arbfd = new_elt;
376 *htab_find_slot (hash_table, (const void *) cache, INSERT) = cache;
377
b34976b6 378 return TRUE;
252b5132
RH
379}
380\f
a8da6403
NC
381static bfd *
382_bfd_find_nested_archive (bfd *arch_bfd, const char *filename)
383{
384 bfd *abfd;
98c53ba3 385 const char *target;
a8da6403
NC
386
387 for (abfd = arch_bfd->nested_archives;
388 abfd != NULL;
389 abfd = abfd->archive_next)
390 {
007d6189 391 if (filename_cmp (filename, abfd->filename) == 0)
3a11e31e 392 return abfd;
a8da6403 393 }
98c53ba3
AM
394 target = NULL;
395 if (!arch_bfd->target_defaulted)
396 target = arch_bfd->xvec->name;
397 abfd = bfd_openr (filename, target);
a8da6403
NC
398 if (abfd)
399 {
400 abfd->archive_next = arch_bfd->nested_archives;
401 arch_bfd->nested_archives = abfd;
402 }
403 return abfd;
404}
405
252b5132 406/* The name begins with space. Hence the rest of the name is an index into
d70910e8 407 the string table. */
252b5132
RH
408
409static char *
a8da6403 410get_extended_arelt_filename (bfd *arch, const char *name, file_ptr *originp)
252b5132 411{
91d6fa6a 412 unsigned long table_index = 0;
a8da6403 413 const char *endp;
252b5132
RH
414
415 /* Should extract string so that I can guarantee not to overflow into
d70910e8 416 the next region, but I'm too lazy. */
252b5132 417 errno = 0;
d70910e8 418 /* Skip first char, which is '/' in SVR4 or ' ' in some other variants. */
91d6fa6a
NC
419 table_index = strtol (name + 1, (char **) &endp, 10);
420 if (errno != 0 || table_index >= bfd_ardata (arch)->extended_names_size)
252b5132
RH
421 {
422 bfd_set_error (bfd_error_malformed_archive);
423 return NULL;
424 }
a8da6403
NC
425 /* In a thin archive, a member of an archive-within-an-archive
426 will have the offset in the inner archive encoded here. */
427 if (bfd_is_thin_archive (arch) && endp != NULL && *endp == ':')
428 {
429 file_ptr origin = strtol (endp + 1, NULL, 10);
430
4ad4f3cb 431 if (errno != 0)
3a11e31e
RM
432 {
433 bfd_set_error (bfd_error_malformed_archive);
434 return NULL;
435 }
a8da6403
NC
436 *originp = origin;
437 }
438 else
439 *originp = 0;
252b5132 440
91d6fa6a 441 return bfd_ardata (arch)->extended_names + table_index;
252b5132
RH
442}
443
444/* This functions reads an arch header and returns an areltdata pointer, or
445 NULL on error.
446
447 Presumes the file pointer is already in the right place (ie pointing
448 to the ar_hdr in the file). Moves the file pointer; on success it
449 should be pointing to the front of the file contents; on failure it
06fc8a8c 450 could have been moved arbitrarily. */
252b5132 451
c58b9523
AM
452void *
453_bfd_generic_read_ar_hdr (bfd *abfd)
252b5132 454{
c58b9523 455 return _bfd_generic_read_ar_hdr_mag (abfd, NULL);
252b5132
RH
456}
457
458/* Alpha ECOFF uses an optional different ARFMAG value, so we have a
459 variant of _bfd_generic_read_ar_hdr which accepts a magic string. */
460
c58b9523
AM
461void *
462_bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
252b5132
RH
463{
464 struct ar_hdr hdr;
465 char *hdrp = (char *) &hdr;
f1bb16f8 466 bfd_size_type parsed_size;
252b5132
RH
467 struct areltdata *ared;
468 char *filename = NULL;
dc810e39
AM
469 bfd_size_type namelen = 0;
470 bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
252b5132 471 char *allocptr = 0;
a8da6403 472 file_ptr origin = 0;
8f95b6e4 473 unsigned int extra_size = 0;
3a11e31e
RM
474 char fmag_save;
475 int scan;
252b5132 476
c58b9523 477 if (bfd_bread (hdrp, sizeof (struct ar_hdr), abfd) != sizeof (struct ar_hdr))
252b5132
RH
478 {
479 if (bfd_get_error () != bfd_error_system_call)
480 bfd_set_error (bfd_error_no_more_archived_files);
481 return NULL;
482 }
483 if (strncmp (hdr.ar_fmag, ARFMAG, 2) != 0
484 && (mag == NULL
485 || strncmp (hdr.ar_fmag, mag, 2) != 0))
486 {
487 bfd_set_error (bfd_error_malformed_archive);
488 return NULL;
489 }
490
491 errno = 0;
3a11e31e 492 fmag_save = hdr.ar_fmag[0];
df35687a 493 hdr.ar_fmag[0] = 0;
3a11e31e
RM
494 scan = sscanf (hdr.ar_size, "%" BFD_VMA_FMT "u", &parsed_size);
495 hdr.ar_fmag[0] = fmag_save;
496 if (scan != 1)
252b5132
RH
497 {
498 bfd_set_error (bfd_error_malformed_archive);
499 return NULL;
500 }
501
502 /* Extract the filename from the archive - there are two ways to
503 specify an extended name table, either the first char of the
504 name is a space, or it's a slash. */
505 if ((hdr.ar_name[0] == '/'
506 || (hdr.ar_name[0] == ' '
507 && memchr (hdr.ar_name, '/', ar_maxnamelen (abfd)) == NULL))
508 && bfd_ardata (abfd)->extended_names != NULL)
509 {
a8da6403 510 filename = get_extended_arelt_filename (abfd, hdr.ar_name, &origin);
252b5132 511 if (filename == NULL)
9e492e05 512 return NULL;
252b5132 513 }
8f95b6e4
TG
514 /* BSD4.4-style long filename. */
515 else if (is_bsd44_extended_name (hdr.ar_name))
252b5132
RH
516 {
517 /* BSD-4.4 extended name */
518 namelen = atoi (&hdr.ar_name[3]);
519 allocsize += namelen + 1;
520 parsed_size -= namelen;
8f95b6e4 521 extra_size = namelen;
252b5132 522
a50b1753 523 allocptr = (char *) bfd_zalloc (abfd, allocsize);
252b5132
RH
524 if (allocptr == NULL)
525 return NULL;
526 filename = (allocptr
527 + sizeof (struct areltdata)
528 + sizeof (struct ar_hdr));
dc810e39 529 if (bfd_bread (filename, namelen, abfd) != namelen)
252b5132
RH
530 {
531 if (bfd_get_error () != bfd_error_system_call)
532 bfd_set_error (bfd_error_no_more_archived_files);
533 return NULL;
534 }
535 filename[namelen] = '\0';
536 }
537 else
538 {
539 /* We judge the end of the name by looking for '/' or ' '.
540 Note: The SYSV format (terminated by '/') allows embedded
d70910e8 541 spaces, so only look for ' ' if we don't find '/'. */
252b5132
RH
542
543 char *e;
a50b1753 544 e = (char *) memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
252b5132
RH
545 if (e == NULL)
546 {
a50b1753 547 e = (char *) memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
252b5132 548 if (e == NULL)
a50b1753 549 e = (char *) memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
252b5132
RH
550 }
551
552 if (e != NULL)
553 namelen = e - hdr.ar_name;
554 else
555 {
556 /* If we didn't find a termination character, then the name
557 must be the entire field. */
558 namelen = ar_maxnamelen (abfd);
559 }
560
561 allocsize += namelen + 1;
562 }
563
564 if (!allocptr)
565 {
a50b1753 566 allocptr = (char *) bfd_zalloc (abfd, allocsize);
252b5132
RH
567 if (allocptr == NULL)
568 return NULL;
569 }
570
571 ared = (struct areltdata *) allocptr;
572
573 ared->arch_header = allocptr + sizeof (struct areltdata);
c58b9523 574 memcpy (ared->arch_header, &hdr, sizeof (struct ar_hdr));
252b5132 575 ared->parsed_size = parsed_size;
8f95b6e4 576 ared->extra_size = extra_size;
a8da6403 577 ared->origin = origin;
252b5132
RH
578
579 if (filename != NULL)
580 ared->filename = filename;
581 else
582 {
583 ared->filename = allocptr + (sizeof (struct areltdata) +
584 sizeof (struct ar_hdr));
585 if (namelen)
c58b9523 586 memcpy (ared->filename, hdr.ar_name, namelen);
252b5132
RH
587 ared->filename[namelen] = '\0';
588 }
589
c58b9523 590 return ared;
252b5132
RH
591}
592\f
a8da6403
NC
593/* Append the relative pathname for a member of the thin archive
594 to the pathname of the directory containing the archive. */
595
4b544b64
TG
596char *
597_bfd_append_relative_path (bfd *arch, char *elt_name)
a8da6403
NC
598{
599 const char *arch_name = arch->filename;
600 const char *base_name = lbasename (arch_name);
601 size_t prefix_len;
602 char *filename;
603
604 if (base_name == arch_name)
605 return elt_name;
606
607 prefix_len = base_name - arch_name;
a50b1753 608 filename = (char *) bfd_alloc (arch, prefix_len + strlen (elt_name) + 1);
a8da6403
NC
609 if (filename == NULL)
610 return NULL;
611
612 strncpy (filename, arch_name, prefix_len);
613 strcpy (filename + prefix_len, elt_name);
614 return filename;
615}
616
252b5132
RH
617/* This is an internal function; it's mainly used when indexing
618 through the archive symbol table, but also used to get the next
619 element, since it handles the bookkeeping so nicely for us. */
620
621bfd *
c58b9523 622_bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos)
252b5132
RH
623{
624 struct areltdata *new_areldata;
625 bfd *n_nfd;
a8da6403 626 char *filename;
252b5132
RH
627
628 n_nfd = _bfd_look_for_bfd_in_cache (archive, filepos);
629 if (n_nfd)
630 return n_nfd;
631
632 if (0 > bfd_seek (archive, filepos, SEEK_SET))
633 return NULL;
634
a50b1753 635 if ((new_areldata = (struct areltdata *) _bfd_read_ar_hdr (archive)) == NULL)
252b5132
RH
636 return NULL;
637
a8da6403
NC
638 filename = new_areldata->filename;
639
640 if (bfd_is_thin_archive (archive))
641 {
98c53ba3
AM
642 const char *target;
643
a8da6403
NC
644 /* This is a proxy entry for an external file. */
645 if (! IS_ABSOLUTE_PATH (filename))
3a11e31e
RM
646 {
647 filename = _bfd_append_relative_path (archive, filename);
648 if (filename == NULL)
649 return NULL;
650 }
a8da6403
NC
651
652 if (new_areldata->origin > 0)
3a11e31e
RM
653 {
654 /* This proxy entry refers to an element of a nested archive.
655 Locate the member of that archive and return a bfd for it. */
656 bfd *ext_arch = _bfd_find_nested_archive (archive, filename);
657
658 if (ext_arch == NULL
659 || ! bfd_check_format (ext_arch, bfd_archive))
660 {
661 bfd_release (archive, new_areldata);
662 return NULL;
663 }
664 n_nfd = _bfd_get_elt_at_filepos (ext_arch, new_areldata->origin);
665 if (n_nfd == NULL)
666 {
667 bfd_release (archive, new_areldata);
668 return NULL;
669 }
670 n_nfd->proxy_origin = bfd_tell (archive);
671 return n_nfd;
672 }
a8da6403 673 /* It's not an element of a nested archive;
3a11e31e 674 open the external file as a bfd. */
98c53ba3
AM
675 target = NULL;
676 if (!archive->target_defaulted)
677 target = archive->xvec->name;
678 n_nfd = bfd_openr (filename, target);
c4948609
NC
679 if (n_nfd == NULL)
680 bfd_set_error (bfd_error_malformed_archive);
a8da6403
NC
681 }
682 else
683 {
684 n_nfd = _bfd_create_empty_archive_element_shell (archive);
685 }
686
252b5132
RH
687 if (n_nfd == NULL)
688 {
c58b9523 689 bfd_release (archive, new_areldata);
252b5132
RH
690 return NULL;
691 }
692
a8da6403
NC
693 n_nfd->proxy_origin = bfd_tell (archive);
694
695 if (bfd_is_thin_archive (archive))
696 {
697 n_nfd->origin = 0;
698 }
699 else
700 {
701 n_nfd->origin = n_nfd->proxy_origin;
702 n_nfd->filename = filename;
703 }
704
c58b9523 705 n_nfd->arelt_data = new_areldata;
252b5132 706
e326bf5f
L
707 /* Copy BFD_COMPRESS and BFD_DECOMPRESS flags. */
708 n_nfd->flags |= archive->flags & (BFD_COMPRESS | BFD_DECOMPRESS);
709
252b5132
RH
710 if (_bfd_add_bfd_to_archive_cache (archive, filepos, n_nfd))
711 return n_nfd;
712
c58b9523 713 bfd_release (archive, new_areldata);
252b5132
RH
714 return NULL;
715}
716
717/* Return the BFD which is referenced by the symbol in ABFD indexed by
91d6fa6a 718 SYM_INDEX. SYM_INDEX should have been returned by bfd_get_next_mapent. */
252b5132
RH
719
720bfd *
91d6fa6a 721_bfd_generic_get_elt_at_index (bfd *abfd, symindex sym_index)
252b5132
RH
722{
723 carsym *entry;
724
91d6fa6a 725 entry = bfd_ardata (abfd)->symdefs + sym_index;
252b5132
RH
726 return _bfd_get_elt_at_filepos (abfd, entry->file_offset);
727}
728
729/*
730FUNCTION
731 bfd_openr_next_archived_file
732
733SYNOPSIS
c58b9523 734 bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous);
252b5132
RH
735
736DESCRIPTION
737 Provided a BFD, @var{archive}, containing an archive and NULL, open
738 an input BFD on the first contained element and returns that.
739 Subsequent calls should pass
740 the archive and the previous return value to return a created
741 BFD to the next contained element. NULL is returned when there
742 are no more.
252b5132
RH
743*/
744
745bfd *
c58b9523 746bfd_openr_next_archived_file (bfd *archive, bfd *last_file)
252b5132 747{
a8da6403
NC
748 if ((bfd_get_format (archive) != bfd_archive)
749 || (archive->direction == write_direction))
252b5132
RH
750 {
751 bfd_set_error (bfd_error_invalid_operation);
752 return NULL;
753 }
754
e326bf5f 755 return BFD_SEND (archive,
c58b9523 756 openr_next_archived_file, (archive, last_file));
252b5132
RH
757}
758
759bfd *
c58b9523 760bfd_generic_openr_next_archived_file (bfd *archive, bfd *last_file)
252b5132
RH
761{
762 file_ptr filestart;
763
764 if (!last_file)
765 filestart = bfd_ardata (archive)->first_file_filepos;
766 else
767 {
f1bb16f8 768 bfd_size_type size = arelt_size (last_file);
c4948609 769
a8da6403
NC
770 filestart = last_file->proxy_origin;
771 if (! bfd_is_thin_archive (archive))
3a11e31e 772 filestart += size;
252b5132
RH
773 /* Pad to an even boundary...
774 Note that last_file->origin can be odd in the case of
d70910e8 775 BSD-4.4-style element with a long odd size. */
252b5132
RH
776 filestart += filestart % 2;
777 }
778
779 return _bfd_get_elt_at_filepos (archive, filestart);
780}
781
252b5132 782const bfd_target *
c58b9523 783bfd_generic_archive_p (bfd *abfd)
252b5132
RH
784{
785 struct artdata *tdata_hold;
786 char armag[SARMAG + 1];
dc810e39 787 bfd_size_type amt;
252b5132 788
c58b9523 789 if (bfd_bread (armag, SARMAG, abfd) != SARMAG)
252b5132
RH
790 {
791 if (bfd_get_error () != bfd_error_system_call)
792 bfd_set_error (bfd_error_wrong_format);
793 return NULL;
794 }
795
a8da6403
NC
796 bfd_is_thin_archive (abfd) = (strncmp (armag, ARMAGT, SARMAG) == 0);
797
798 if (strncmp (armag, ARMAG, SARMAG) != 0
799 && strncmp (armag, ARMAGB, SARMAG) != 0
800 && ! bfd_is_thin_archive (abfd))
c4948609 801 return NULL;
252b5132 802
487e54f2 803 tdata_hold = bfd_ardata (abfd);
252b5132 804
487e54f2 805 amt = sizeof (struct artdata);
a50b1753 806 bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
252b5132 807 if (bfd_ardata (abfd) == NULL)
487e54f2
AM
808 {
809 bfd_ardata (abfd) = tdata_hold;
810 return NULL;
811 }
252b5132
RH
812
813 bfd_ardata (abfd)->first_file_filepos = SARMAG;
9e492e05
JJ
814 /* Cleared by bfd_zalloc above.
815 bfd_ardata (abfd)->cache = NULL;
816 bfd_ardata (abfd)->archive_head = NULL;
817 bfd_ardata (abfd)->symdefs = NULL;
818 bfd_ardata (abfd)->extended_names = NULL;
819 bfd_ardata (abfd)->extended_names_size = 0;
820 bfd_ardata (abfd)->tdata = NULL; */
252b5132 821
487e54f2
AM
822 if (!BFD_SEND (abfd, _bfd_slurp_armap, (abfd))
823 || !BFD_SEND (abfd, _bfd_slurp_extended_name_table, (abfd)))
252b5132 824 {
252b5132
RH
825 if (bfd_get_error () != bfd_error_system_call)
826 bfd_set_error (bfd_error_wrong_format);
252b5132 827 bfd_release (abfd, bfd_ardata (abfd));
487e54f2 828 bfd_ardata (abfd) = tdata_hold;
252b5132
RH
829 return NULL;
830 }
831
b228303d 832 if (abfd->target_defaulted && bfd_has_map (abfd))
252b5132
RH
833 {
834 bfd *first;
835
836 /* This archive has a map, so we may presume that the contents
837 are object files. Make sure that if the first file in the
838 archive can be recognized as an object file, it is for this
839 target. If not, assume that this is the wrong format. If
840 the first file is not an object file, somebody is doing
841 something weird, and we permit it so that ar -t will work.
842
843 This is done because any normal format will recognize any
844 normal archive, regardless of the format of the object files.
845 We do accept an empty archive. */
846
c58b9523 847 first = bfd_openr_next_archived_file (abfd, NULL);
252b5132
RH
848 if (first != NULL)
849 {
b34976b6 850 first->target_defaulted = FALSE;
252b5132
RH
851 if (bfd_check_format (first, bfd_object)
852 && first->xvec != abfd->xvec)
853 {
3619ad04 854 bfd_set_error (bfd_error_wrong_object_format);
487e54f2 855 bfd_ardata (abfd) = tdata_hold;
252b5132
RH
856 return NULL;
857 }
3619ad04 858 /* And we ought to close `first' here too. */
252b5132
RH
859 }
860 }
861
862 return abfd->xvec;
863}
864
865/* Some constants for a 32 bit BSD archive structure. We do not
866 support 64 bit archives presently; so far as I know, none actually
867 exist. Supporting them would require changing these constants, and
dc810e39 868 changing some H_GET_32 to H_GET_64. */
252b5132
RH
869
870/* The size of an external symdef structure. */
871#define BSD_SYMDEF_SIZE 8
872
873/* The offset from the start of a symdef structure to the file offset. */
874#define BSD_SYMDEF_OFFSET_SIZE 4
875
876/* The size of the symdef count. */
877#define BSD_SYMDEF_COUNT_SIZE 4
878
879/* The size of the string count. */
880#define BSD_STRING_COUNT_SIZE 4
881
36e44abd
AN
882/* Read a BSD-style archive symbol table. Returns FALSE on error,
883 TRUE otherwise. */
252b5132 884
b34976b6 885static bfd_boolean
c58b9523 886do_slurp_bsd_armap (bfd *abfd)
252b5132
RH
887{
888 struct areltdata *mapdata;
889 unsigned int counter;
890 bfd_byte *raw_armap, *rbase;
891 struct artdata *ardata = bfd_ardata (abfd);
892 char *stringbase;
dc810e39 893 bfd_size_type parsed_size, amt;
252b5132
RH
894 carsym *set;
895
a50b1753 896 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
252b5132 897 if (mapdata == NULL)
b34976b6 898 return FALSE;
252b5132 899 parsed_size = mapdata->parsed_size;
c58b9523 900 bfd_release (abfd, mapdata); /* Don't need it any more. */
252b5132 901
a50b1753 902 raw_armap = (bfd_byte *) bfd_zalloc (abfd, parsed_size);
c58b9523 903 if (raw_armap == NULL)
b34976b6 904 return FALSE;
252b5132 905
c58b9523 906 if (bfd_bread (raw_armap, parsed_size, abfd) != parsed_size)
252b5132
RH
907 {
908 if (bfd_get_error () != bfd_error_system_call)
909 bfd_set_error (bfd_error_malformed_archive);
910 byebye:
c58b9523 911 bfd_release (abfd, raw_armap);
b34976b6 912 return FALSE;
252b5132
RH
913 }
914
dc810e39 915 ardata->symdef_count = H_GET_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE;
252b5132
RH
916
917 if (ardata->symdef_count * BSD_SYMDEF_SIZE >
918 parsed_size - BSD_SYMDEF_COUNT_SIZE)
919 {
920 /* Probably we're using the wrong byte ordering. */
921 bfd_set_error (bfd_error_wrong_format);
922 goto byebye;
923 }
924
925 ardata->cache = 0;
926 rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE;
927 stringbase = ((char *) rbase
928 + ardata->symdef_count * BSD_SYMDEF_SIZE
929 + BSD_STRING_COUNT_SIZE);
c58b9523 930 amt = ardata->symdef_count * sizeof (carsym);
a50b1753 931 ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt);
252b5132 932 if (!ardata->symdefs)
b34976b6 933 return FALSE;
252b5132
RH
934
935 for (counter = 0, set = ardata->symdefs;
936 counter < ardata->symdef_count;
937 counter++, set++, rbase += BSD_SYMDEF_SIZE)
938 {
dc810e39
AM
939 set->name = H_GET_32 (abfd, rbase) + stringbase;
940 set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
252b5132
RH
941 }
942
943 ardata->first_file_filepos = bfd_tell (abfd);
047066e1 944 /* Pad to an even boundary if you have to. */
252b5132
RH
945 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
946 /* FIXME, we should provide some way to free raw_ardata when
947 we are done using the strings from it. For now, it seems
d70910e8 948 to be allocated on an objalloc anyway... */
b34976b6
AM
949 bfd_has_map (abfd) = TRUE;
950 return TRUE;
252b5132
RH
951}
952
36e44abd
AN
953/* Read a COFF archive symbol table. Returns FALSE on error, TRUE
954 otherwise. */
047066e1 955
b34976b6 956static bfd_boolean
c58b9523 957do_slurp_coff_armap (bfd *abfd)
252b5132
RH
958{
959 struct areltdata *mapdata;
960 int *raw_armap, *rawptr;
961 struct artdata *ardata = bfd_ardata (abfd);
962 char *stringbase;
dc810e39 963 bfd_size_type stringsize;
f1bb16f8 964 bfd_size_type parsed_size;
252b5132 965 carsym *carsyms;
dc810e39 966 bfd_size_type nsymz; /* Number of symbols in armap. */
edeb6e24 967 bfd_vma (*swap) (const void *);
252b5132 968 char int_buf[sizeof (long)];
dc810e39
AM
969 bfd_size_type carsym_size, ptrsize;
970 unsigned int i;
252b5132 971
a50b1753 972 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
252b5132 973 if (mapdata == NULL)
b34976b6 974 return FALSE;
252b5132 975 parsed_size = mapdata->parsed_size;
c58b9523 976 bfd_release (abfd, mapdata); /* Don't need it any more. */
252b5132 977
c58b9523 978 if (bfd_bread (int_buf, 4, abfd) != 4)
252b5132
RH
979 {
980 if (bfd_get_error () != bfd_error_system_call)
981 bfd_set_error (bfd_error_malformed_archive);
b34976b6 982 return FALSE;
252b5132
RH
983 }
984 /* It seems that all numeric information in a coff archive is always
d70910e8 985 in big endian format, nomatter the host or target. */
252b5132 986 swap = bfd_getb32;
c58b9523 987 nsymz = bfd_getb32 (int_buf);
252b5132
RH
988 stringsize = parsed_size - (4 * nsymz) - 4;
989
252b5132
RH
990 /* ... except that some archive formats are broken, and it may be our
991 fault - the i960 little endian coff sometimes has big and sometimes
992 little, because our tools changed. Here's a horrible hack to clean
993 up the crap. */
994
995 if (stringsize > 0xfffff
996 && bfd_get_arch (abfd) == bfd_arch_i960
997 && bfd_get_flavour (abfd) == bfd_target_coff_flavour)
998 {
047066e1 999 /* This looks dangerous, let's do it the other way around. */
c58b9523 1000 nsymz = bfd_getl32 (int_buf);
252b5132
RH
1001 stringsize = parsed_size - (4 * nsymz) - 4;
1002 swap = bfd_getl32;
1003 }
252b5132
RH
1004
1005 /* The coff armap must be read sequentially. So we construct a
d70910e8 1006 bsd-style one in core all at once, for simplicity. */
252b5132 1007
933d961a
JJ
1008 if (nsymz > ~ (bfd_size_type) 0 / sizeof (carsym))
1009 return FALSE;
1010
252b5132
RH
1011 carsym_size = (nsymz * sizeof (carsym));
1012 ptrsize = (4 * nsymz);
1013
933d961a
JJ
1014 if (carsym_size + stringsize + 1 <= carsym_size)
1015 return FALSE;
1016
a50b1753 1017 ardata->symdefs = (struct carsym *) bfd_zalloc (abfd,
3a11e31e 1018 carsym_size + stringsize + 1);
252b5132 1019 if (ardata->symdefs == NULL)
b34976b6 1020 return FALSE;
252b5132
RH
1021 carsyms = ardata->symdefs;
1022 stringbase = ((char *) ardata->symdefs) + carsym_size;
1023
d70910e8 1024 /* Allocate and read in the raw offsets. */
a50b1753 1025 raw_armap = (int *) bfd_alloc (abfd, ptrsize);
252b5132
RH
1026 if (raw_armap == NULL)
1027 goto release_symdefs;
c58b9523
AM
1028 if (bfd_bread (raw_armap, ptrsize, abfd) != ptrsize
1029 || (bfd_bread (stringbase, stringsize, abfd) != stringsize))
252b5132
RH
1030 {
1031 if (bfd_get_error () != bfd_error_system_call)
1032 bfd_set_error (bfd_error_malformed_archive);
1033 goto release_raw_armap;
1034 }
1035
047066e1 1036 /* OK, build the carsyms. */
252b5132
RH
1037 for (i = 0; i < nsymz; i++)
1038 {
1039 rawptr = raw_armap + i;
c58b9523 1040 carsyms->file_offset = swap ((bfd_byte *) rawptr);
252b5132
RH
1041 carsyms->name = stringbase;
1042 stringbase += strlen (stringbase) + 1;
1043 carsyms++;
1044 }
1045 *stringbase = 0;
1046
1047 ardata->symdef_count = nsymz;
1048 ardata->first_file_filepos = bfd_tell (abfd);
047066e1 1049 /* Pad to an even boundary if you have to. */
252b5132
RH
1050 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1051
b34976b6 1052 bfd_has_map (abfd) = TRUE;
c58b9523 1053 bfd_release (abfd, raw_armap);
252b5132 1054
047066e1 1055 /* Check for a second archive header (as used by PE). */
252b5132
RH
1056 {
1057 struct areltdata *tmp;
1058
dc810e39 1059 bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET);
a50b1753 1060 tmp = (struct areltdata *) _bfd_read_ar_hdr (abfd);
23afc6f6 1061 if (tmp != NULL)
252b5132
RH
1062 {
1063 if (tmp->arch_header[0] == '/'
23afc6f6 1064 && tmp->arch_header[1] == ' ')
252b5132
RH
1065 {
1066 ardata->first_file_filepos +=
dc810e39 1067 (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1;
252b5132
RH
1068 }
1069 bfd_release (abfd, tmp);
1070 }
1071 }
1072
b34976b6 1073 return TRUE;
252b5132
RH
1074
1075release_raw_armap:
c58b9523 1076 bfd_release (abfd, raw_armap);
252b5132 1077release_symdefs:
c58b9523 1078 bfd_release (abfd, (ardata)->symdefs);
b34976b6 1079 return FALSE;
252b5132
RH
1080}
1081
36e44abd
AN
1082/* This routine can handle either coff-style or bsd-style armaps
1083 (archive symbol table). Returns FALSE on error, TRUE otherwise */
252b5132 1084
b34976b6 1085bfd_boolean
c58b9523 1086bfd_slurp_armap (bfd *abfd)
252b5132
RH
1087{
1088 char nextname[17];
c58b9523 1089 int i = bfd_bread (nextname, 16, abfd);
252b5132
RH
1090
1091 if (i == 0)
b34976b6 1092 return TRUE;
252b5132 1093 if (i != 16)
b34976b6 1094 return FALSE;
252b5132 1095
dc810e39 1096 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
b34976b6 1097 return FALSE;
252b5132 1098
0112cd26
NC
1099 if (CONST_STRNEQ (nextname, "__.SYMDEF ")
1100 || CONST_STRNEQ (nextname, "__.SYMDEF/ ")) /* Old Linux archives. */
252b5132 1101 return do_slurp_bsd_armap (abfd);
0112cd26 1102 else if (CONST_STRNEQ (nextname, "/ "))
252b5132 1103 return do_slurp_coff_armap (abfd);
0112cd26 1104 else if (CONST_STRNEQ (nextname, "/SYM64/ "))
252b5132 1105 {
36b45482
TS
1106 /* 64bit ELF (Irix 6) archive. */
1107#ifdef BFD64
c58b9523 1108 extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *);
36b45482
TS
1109 return bfd_elf64_archive_slurp_armap (abfd);
1110#else
252b5132 1111 bfd_set_error (bfd_error_wrong_format);
b34976b6 1112 return FALSE;
36b45482 1113#endif
252b5132 1114 }
cba0723b
TG
1115 else if (CONST_STRNEQ (nextname, "#1/20 "))
1116 {
1117 /* Mach-O has a special name for armap when the map is sorted by name.
3a11e31e
RM
1118 However because this name has a space it is slightly more difficult
1119 to check it. */
cba0723b
TG
1120 struct ar_hdr hdr;
1121 char extname[21];
1122
1123 if (bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
3a11e31e 1124 return FALSE;
cba0723b
TG
1125 /* Read the extended name. We know its length. */
1126 if (bfd_bread (extname, 20, abfd) != 20)
3a11e31e 1127 return FALSE;
cd99171c 1128 if (bfd_seek (abfd, -(file_ptr) (sizeof (hdr) + 20), SEEK_CUR) != 0)
3a11e31e 1129 return FALSE;
8f95b6e4 1130 if (CONST_STRNEQ (extname, "__.SYMDEF SORTED")
3a11e31e
RM
1131 || CONST_STRNEQ (extname, "__.SYMDEF"))
1132 return do_slurp_bsd_armap (abfd);
cba0723b 1133 }
252b5132 1134
b34976b6
AM
1135 bfd_has_map (abfd) = FALSE;
1136 return TRUE;
252b5132
RH
1137}
1138\f
06fc8a8c
NC
1139/* Returns FALSE on error, TRUE otherwise. */
1140/* Flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
252b5132 1141 header is in a slightly different order and the map name is '/'.
d70910e8 1142 This flavour is used by hp300hpux. */
252b5132
RH
1143
1144#define HPUX_SYMDEF_COUNT_SIZE 2
1145
b34976b6 1146bfd_boolean
c58b9523 1147bfd_slurp_bsd_armap_f2 (bfd *abfd)
252b5132
RH
1148{
1149 struct areltdata *mapdata;
1150 char nextname[17];
1151 unsigned int counter;
1152 bfd_byte *raw_armap, *rbase;
1153 struct artdata *ardata = bfd_ardata (abfd);
1154 char *stringbase;
1155 unsigned int stringsize;
8616ad89 1156 unsigned int left;
dc810e39 1157 bfd_size_type amt;
252b5132 1158 carsym *set;
c58b9523 1159 int i = bfd_bread (nextname, 16, abfd);
252b5132
RH
1160
1161 if (i == 0)
b34976b6 1162 return TRUE;
252b5132 1163 if (i != 16)
b34976b6 1164 return FALSE;
252b5132 1165
047066e1 1166 /* The archive has at least 16 bytes in it. */
dc810e39 1167 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
b34976b6 1168 return FALSE;
252b5132 1169
0112cd26
NC
1170 if (CONST_STRNEQ (nextname, "__.SYMDEF ")
1171 || CONST_STRNEQ (nextname, "__.SYMDEF/ ")) /* Old Linux archives. */
252b5132
RH
1172 return do_slurp_bsd_armap (abfd);
1173
0112cd26 1174 if (! CONST_STRNEQ (nextname, "/ "))
252b5132 1175 {
b34976b6
AM
1176 bfd_has_map (abfd) = FALSE;
1177 return TRUE;
252b5132
RH
1178 }
1179
a50b1753 1180 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
252b5132 1181 if (mapdata == NULL)
b34976b6 1182 return FALSE;
252b5132 1183
8616ad89 1184 if (mapdata->parsed_size < HPUX_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE)
252b5132 1185 {
8616ad89
AM
1186 wrong_format:
1187 bfd_set_error (bfd_error_wrong_format);
252b5132 1188 byebye:
c58b9523 1189 bfd_release (abfd, mapdata);
b34976b6 1190 return FALSE;
252b5132 1191 }
8616ad89
AM
1192 left = mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE - BSD_STRING_COUNT_SIZE;
1193
1194 amt = mapdata->parsed_size;
1195 raw_armap = (bfd_byte *) bfd_zalloc (abfd, amt);
1196 if (raw_armap == NULL)
1197 goto byebye;
252b5132 1198
c58b9523 1199 if (bfd_bread (raw_armap, amt, abfd) != amt)
252b5132
RH
1200 {
1201 if (bfd_get_error () != bfd_error_system_call)
1202 bfd_set_error (bfd_error_malformed_archive);
252b5132
RH
1203 goto byebye;
1204 }
1205
c58b9523 1206 ardata->symdef_count = H_GET_16 (abfd, raw_armap);
252b5132 1207
252b5132
RH
1208 ardata->cache = 0;
1209
dc810e39 1210 stringsize = H_GET_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE);
8616ad89
AM
1211 if (stringsize > left)
1212 goto wrong_format;
1213 left -= stringsize;
1214
047066e1 1215 /* Skip sym count and string sz. */
252b5132
RH
1216 stringbase = ((char *) raw_armap
1217 + HPUX_SYMDEF_COUNT_SIZE
1218 + BSD_STRING_COUNT_SIZE);
1219 rbase = (bfd_byte *) stringbase + stringsize;
c58b9523 1220 amt = ardata->symdef_count * BSD_SYMDEF_SIZE;
8616ad89
AM
1221 if (amt > left)
1222 goto wrong_format;
1223
a50b1753 1224 ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt);
252b5132 1225 if (!ardata->symdefs)
b34976b6 1226 return FALSE;
252b5132
RH
1227
1228 for (counter = 0, set = ardata->symdefs;
1229 counter < ardata->symdef_count;
1230 counter++, set++, rbase += BSD_SYMDEF_SIZE)
1231 {
dc810e39
AM
1232 set->name = H_GET_32 (abfd, rbase) + stringbase;
1233 set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
252b5132
RH
1234 }
1235
1236 ardata->first_file_filepos = bfd_tell (abfd);
047066e1 1237 /* Pad to an even boundary if you have to. */
252b5132
RH
1238 ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1239 /* FIXME, we should provide some way to free raw_ardata when
1240 we are done using the strings from it. For now, it seems
d70910e8 1241 to be allocated on an objalloc anyway... */
b34976b6
AM
1242 bfd_has_map (abfd) = TRUE;
1243 return TRUE;
252b5132
RH
1244}
1245\f
1246/** Extended name table.
1247
1248 Normally archives support only 14-character filenames.
1249
1250 Intel has extended the format: longer names are stored in a special
1251 element (the first in the archive, or second if there is an armap);
1252 the name in the ar_hdr is replaced by <space><index into filename
1253 element>. Index is the P.R. of an int (decimal). Data General have
047066e1
KH
1254 extended the format by using the prefix // for the special element. */
1255
b34976b6 1256/* Returns FALSE on error, TRUE otherwise. */
252b5132 1257
b34976b6 1258bfd_boolean
c58b9523 1259_bfd_slurp_extended_name_table (bfd *abfd)
252b5132
RH
1260{
1261 char nextname[17];
1262 struct areltdata *namedata;
dc810e39 1263 bfd_size_type amt;
252b5132
RH
1264
1265 /* FIXME: Formatting sucks here, and in case of failure of BFD_READ,
b34976b6 1266 we probably don't want to return TRUE. */
eb00922a
MS
1267 if (bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET) != 0)
1268 return FALSE;
1269
c58b9523 1270 if (bfd_bread (nextname, 16, abfd) == 16)
252b5132 1271 {
dc810e39 1272 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0)
b34976b6 1273 return FALSE;
252b5132 1274
0112cd26
NC
1275 if (! CONST_STRNEQ (nextname, "ARFILENAMES/ ")
1276 && ! CONST_STRNEQ (nextname, "// "))
252b5132
RH
1277 {
1278 bfd_ardata (abfd)->extended_names = NULL;
9e492e05 1279 bfd_ardata (abfd)->extended_names_size = 0;
b34976b6 1280 return TRUE;
252b5132
RH
1281 }
1282
a50b1753 1283 namedata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
252b5132 1284 if (namedata == NULL)
b34976b6 1285 return FALSE;
252b5132 1286
dc810e39 1287 amt = namedata->parsed_size;
9e492e05 1288 if (amt + 1 == 0)
3a11e31e 1289 goto byebye;
9e492e05
JJ
1290
1291 bfd_ardata (abfd)->extended_names_size = amt;
a50b1753 1292 bfd_ardata (abfd)->extended_names = (char *) bfd_zalloc (abfd, amt + 1);
252b5132
RH
1293 if (bfd_ardata (abfd)->extended_names == NULL)
1294 {
1295 byebye:
c58b9523 1296 bfd_release (abfd, namedata);
b34976b6 1297 return FALSE;
252b5132
RH
1298 }
1299
c58b9523 1300 if (bfd_bread (bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
252b5132
RH
1301 {
1302 if (bfd_get_error () != bfd_error_system_call)
1303 bfd_set_error (bfd_error_malformed_archive);
c58b9523 1304 bfd_release (abfd, (bfd_ardata (abfd)->extended_names));
252b5132
RH
1305 bfd_ardata (abfd)->extended_names = NULL;
1306 goto byebye;
1307 }
1308
1309 /* Since the archive is supposed to be printable if it contains
1310 text, the entries in the list are newline-padded, not null
1311 padded. In SVR4-style archives, the names also have a
1312 trailing '/'. DOS/NT created archive often have \ in them
1313 We'll fix all problems here.. */
1314 {
3a11e31e 1315 char *ext_names = bfd_ardata (abfd)->extended_names;
9e492e05 1316 char *temp = ext_names;
252b5132 1317 char *limit = temp + namedata->parsed_size;
047066e1
KH
1318 for (; temp < limit; ++temp)
1319 {
89a58aeb 1320 if (*temp == ARFMAG[1])
9e492e05 1321 temp[temp > ext_names && temp[-1] == '/' ? -1 : 0] = '\0';
047066e1
KH
1322 if (*temp == '\\')
1323 *temp = '/';
1324 }
9e492e05 1325 *limit = '\0';
252b5132
RH
1326 }
1327
047066e1 1328 /* Pad to an even boundary if you have to. */
252b5132
RH
1329 bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd);
1330 bfd_ardata (abfd)->first_file_filepos +=
1331 (bfd_ardata (abfd)->first_file_filepos) % 2;
1332
1333 /* FIXME, we can't release namedata here because it was allocated
d70910e8 1334 below extended_names on the objalloc... */
252b5132 1335 }
b34976b6 1336 return TRUE;
252b5132
RH
1337}
1338
1339#ifdef VMS
1340
1341/* Return a copy of the stuff in the filename between any :]> and a
047066e1
KH
1342 semicolon. */
1343
252b5132 1344static const char *
c58b9523 1345normalize (bfd *abfd, const char *file)
252b5132 1346{
dc810e39
AM
1347 const char *first;
1348 const char *last;
252b5132
RH
1349 char *copy;
1350
1351 first = file + strlen (file) - 1;
1352 last = first + 1;
1353
1354 while (first != file)
1355 {
1356 if (*first == ';')
1357 last = first;
1358 if (*first == ':' || *first == ']' || *first == '>')
1359 {
1360 first++;
1361 break;
1362 }
1363 first--;
1364 }
1365
c58b9523 1366 copy = bfd_alloc (abfd, last - first + 1);
252b5132
RH
1367 if (copy == NULL)
1368 return NULL;
1369
1370 memcpy (copy, first, last - first);
1371 copy[last - first] = 0;
1372
1373 return copy;
1374}
1375
1376#else
1377static const char *
c58b9523 1378normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file)
252b5132 1379{
19172f39 1380 return lbasename (file);
252b5132
RH
1381}
1382#endif
1383
c4948609
NC
1384/* Adjust a relative path name based on the reference path.
1385 For example:
1386
1387 Relative path Reference path Result
1388 ------------- -------------- ------
1389 bar.o lib.a bar.o
1390 foo/bar.o lib.a foo/bar.o
1391 bar.o foo/lib.a ../bar.o
1392 foo/bar.o baz/lib.a ../foo/bar.o
1393 bar.o ../lib.a <parent of current dir>/bar.o
74ce8de7
NC
1394 ; ../bar.o ../lib.a bar.o
1395 ; ../bar.o lib.a ../bar.o
c4948609
NC
1396 foo/bar.o ../lib.a <parent of current dir>/foo/bar.o
1397 bar.o ../../lib.a <grandparent>/<parent>/bar.o
1398 bar.o foo/baz/lib.a ../../bar.o
1399
74ce8de7
NC
1400 Note - the semicolons above are there to prevent the BFD chew
1401 utility from interpreting those lines as prototypes to put into
1402 the autogenerated bfd.h header...
a8da6403 1403
74ce8de7 1404 Note - the string is returned in a static buffer. */
3a11e31e 1405
a8da6403
NC
1406static const char *
1407adjust_relative_path (const char * path, const char * ref_path)
1408{
1409 static char *pathbuf = NULL;
c4948609
NC
1410 static unsigned int pathbuf_len = 0;
1411 const char *pathp;
1412 const char *refp;
1413 char * lpath;
1414 char * rpath;
1415 unsigned int len;
1416 unsigned int dir_up = 0;
1417 unsigned int dir_down = 0;
a8da6403 1418 char *newp;
c4948609
NC
1419 char * pwd = getpwd ();
1420 const char * down;
a8da6403 1421
c4948609
NC
1422 /* Remove symlinks, '.' and '..' from the paths, if possible. */
1423 lpath = lrealpath (path);
1424 pathp = lpath == NULL ? path : lpath;
1425
1426 rpath = lrealpath (ref_path);
1427 refp = rpath == NULL ? ref_path : rpath;
3a11e31e 1428
a8da6403
NC
1429 /* Remove common leading path elements. */
1430 for (;;)
1431 {
1432 const char *e1 = pathp;
1433 const char *e2 = refp;
1434
1435 while (*e1 && ! IS_DIR_SEPARATOR (*e1))
1436 ++e1;
1437 while (*e2 && ! IS_DIR_SEPARATOR (*e2))
1438 ++e2;
1439 if (*e1 == '\0' || *e2 == '\0' || e1 - pathp != e2 - refp
007d6189 1440 || filename_ncmp (pathp, refp, e1 - pathp) != 0)
a8da6403
NC
1441 break;
1442 pathp = e1 + 1;
1443 refp = e2 + 1;
1444 }
1445
c4948609 1446 len = strlen (pathp) + 1;
a8da6403
NC
1447 /* For each leading path element in the reference path,
1448 insert "../" into the path. */
1449 for (; *refp; ++refp)
1450 if (IS_DIR_SEPARATOR (*refp))
c4948609
NC
1451 {
1452 /* PR 12710: If the path element is "../" then instead of
1453 inserting "../" we need to insert the name of the directory
3a11e31e 1454 at the current level. */
c4948609
NC
1455 if (refp > ref_path + 1
1456 && refp[-1] == '.'
1457 && refp[-2] == '.')
1458 dir_down ++;
1459 else
1460 dir_up ++;
1461 }
1462
1463 /* If the lrealpath calls above succeeded then we should never
1464 see dir_up and dir_down both being non-zero. */
3a11e31e 1465
c4948609
NC
1466 len += 3 * dir_up;
1467
1468 if (dir_down)
1469 {
1470 down = pwd + strlen (pwd) - 1;
1471
1472 while (dir_down && down > pwd)
1473 {
1474 if (IS_DIR_SEPARATOR (*down))
1475 --dir_down;
1476 }
1477 BFD_ASSERT (dir_down == 0);
1478 len += strlen (down) + 1;
1479 }
1480 else
1481 down = NULL;
a8da6403
NC
1482
1483 if (len > pathbuf_len)
1484 {
1485 if (pathbuf != NULL)
1486 free (pathbuf);
1487 pathbuf_len = 0;
a50b1753 1488 pathbuf = (char *) bfd_malloc (len);
a8da6403 1489 if (pathbuf == NULL)
c4948609 1490 goto out;
a8da6403
NC
1491 pathbuf_len = len;
1492 }
1493
1494 newp = pathbuf;
c4948609 1495 while (dir_up-- > 0)
a8da6403
NC
1496 {
1497 /* FIXME: Support Windows style path separators as well. */
1498 strcpy (newp, "../");
1499 newp += 3;
1500 }
a8da6403 1501
c4948609
NC
1502 if (down)
1503 sprintf (newp, "%s/%s", down, pathp);
1504 else
1505 strcpy (newp, pathp);
1506
1507 out:
1508 free (lpath);
1509 free (rpath);
a8da6403
NC
1510 return pathbuf;
1511}
1512
252b5132
RH
1513/* Build a BFD style extended name table. */
1514
b34976b6 1515bfd_boolean
c58b9523
AM
1516_bfd_archive_bsd_construct_extended_name_table (bfd *abfd,
1517 char **tabloc,
1518 bfd_size_type *tablen,
1519 const char **name)
252b5132
RH
1520{
1521 *name = "ARFILENAMES/";
b34976b6 1522 return _bfd_construct_extended_name_table (abfd, FALSE, tabloc, tablen);
252b5132
RH
1523}
1524
1525/* Build an SVR4 style extended name table. */
1526
b34976b6 1527bfd_boolean
c58b9523
AM
1528_bfd_archive_coff_construct_extended_name_table (bfd *abfd,
1529 char **tabloc,
1530 bfd_size_type *tablen,
1531 const char **name)
252b5132
RH
1532{
1533 *name = "//";
b34976b6 1534 return _bfd_construct_extended_name_table (abfd, TRUE, tabloc, tablen);
252b5132
RH
1535}
1536
1537/* Follows archive_head and produces an extended name table if
1538 necessary. Returns (in tabloc) a pointer to an extended name
1539 table, and in tablen the length of the table. If it makes an entry
1540 it clobbers the filename so that the element may be written without
b34976b6 1541 further massage. Returns TRUE if it ran successfully, FALSE if
252b5132
RH
1542 something went wrong. A successful return may still involve a
1543 zero-length tablen! */
1544
b34976b6 1545bfd_boolean
c58b9523
AM
1546_bfd_construct_extended_name_table (bfd *abfd,
1547 bfd_boolean trailing_slash,
1548 char **tabloc,
1549 bfd_size_type *tablen)
252b5132 1550{
b228303d 1551 unsigned int maxname = ar_maxnamelen (abfd);
dc810e39 1552 bfd_size_type total_namelen = 0;
252b5132
RH
1553 bfd *current;
1554 char *strptr;
a8da6403
NC
1555 const char *last_filename;
1556 long last_stroff;
252b5132
RH
1557
1558 *tablen = 0;
a8da6403 1559 last_filename = NULL;
252b5132 1560
047066e1 1561 /* Figure out how long the table should be. */
cc481421
AM
1562 for (current = abfd->archive_head;
1563 current != NULL;
1564 current = current->archive_next)
252b5132
RH
1565 {
1566 const char *normal;
1567 unsigned int thislen;
1568
a8da6403 1569 if (bfd_is_thin_archive (abfd))
3a11e31e
RM
1570 {
1571 const char *filename = current->filename;
1572
1573 /* If the element being added is a member of another archive
1574 (i.e., we are flattening), use the containing archive's name. */
1575 if (current->my_archive
1576 && ! bfd_is_thin_archive (current->my_archive))
1577 filename = current->my_archive->filename;
1578
1579 /* If the path is the same as the previous path seen,
1580 reuse it. This can happen when flattening a thin
1581 archive that contains other archives. */
1582 if (last_filename && filename_cmp (last_filename, filename) == 0)
1583 continue;
1584
1585 last_filename = filename;
1586
1587 /* If the path is relative, adjust it relative to
1588 the containing archive. */
1589 if (! IS_ABSOLUTE_PATH (filename)
1590 && ! IS_ABSOLUTE_PATH (abfd->filename))
1591 normal = adjust_relative_path (filename, abfd->filename);
1592 else
1593 normal = filename;
1594
1595 /* In a thin archive, always store the full pathname
1596 in the extended name table. */
1597 total_namelen += strlen (normal) + 1;
a8da6403
NC
1598 if (trailing_slash)
1599 /* Leave room for trailing slash. */
1600 ++total_namelen;
1601
3a11e31e
RM
1602 continue;
1603 }
a8da6403 1604
252b5132
RH
1605 normal = normalize (current, current->filename);
1606 if (normal == NULL)
b34976b6 1607 return FALSE;
252b5132
RH
1608
1609 thislen = strlen (normal);
1610
1611 if (thislen > maxname
1612 && (bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1613 thislen = maxname;
1614
1615 if (thislen > maxname)
1616 {
1617 /* Add one to leave room for \n. */
1618 total_namelen += thislen + 1;
1619 if (trailing_slash)
1620 {
1621 /* Leave room for trailing slash. */
1622 ++total_namelen;
1623 }
1624 }
1625 else
1626 {
1627 struct ar_hdr *hdr = arch_hdr (current);
007d6189 1628 if (filename_ncmp (normal, hdr->ar_name, thislen) != 0
252b5132
RH
1629 || (thislen < sizeof hdr->ar_name
1630 && hdr->ar_name[thislen] != ar_padchar (current)))
1631 {
1632 /* Must have been using extended format even though it
3a11e31e 1633 didn't need to. Fix it to use normal format. */
252b5132
RH
1634 memcpy (hdr->ar_name, normal, thislen);
1635 if (thislen < maxname
1636 || (thislen == maxname && thislen < sizeof hdr->ar_name))
1637 hdr->ar_name[thislen] = ar_padchar (current);
1638 }
1639 }
1640 }
1641
1642 if (total_namelen == 0)
b34976b6 1643 return TRUE;
252b5132 1644
a50b1753 1645 *tabloc = (char *) bfd_zalloc (abfd, total_namelen);
252b5132 1646 if (*tabloc == NULL)
b34976b6 1647 return FALSE;
252b5132
RH
1648
1649 *tablen = total_namelen;
1650 strptr = *tabloc;
1651
a8da6403
NC
1652 last_filename = NULL;
1653 last_stroff = 0;
1654
cc481421
AM
1655 for (current = abfd->archive_head;
1656 current != NULL;
1657 current = current->archive_next)
252b5132
RH
1658 {
1659 const char *normal;
1660 unsigned int thislen;
a8da6403
NC
1661 long stroff;
1662 const char *filename = current->filename;
1663
1664 if (bfd_is_thin_archive (abfd))
3a11e31e
RM
1665 {
1666 /* If the element being added is a member of another archive
1667 (i.e., we are flattening), use the containing archive's name. */
1668 if (current->my_archive
1669 && ! bfd_is_thin_archive (current->my_archive))
1670 filename = current->my_archive->filename;
1671 /* If the path is the same as the previous path seen,
1672 reuse it. This can happen when flattening a thin
1673 archive that contains other archives.
1674 If the path is relative, adjust it relative to
1675 the containing archive. */
1676 if (last_filename && filename_cmp (last_filename, filename) == 0)
1677 normal = last_filename;
1678 else if (! IS_ABSOLUTE_PATH (filename)
1679 && ! IS_ABSOLUTE_PATH (abfd->filename))
1680 normal = adjust_relative_path (filename, abfd->filename);
1681 else
1682 normal = filename;
1683 }
a8da6403 1684 else
3a11e31e
RM
1685 {
1686 normal = normalize (current, filename);
1687 if (normal == NULL)
1688 return FALSE;
1689 }
252b5132
RH
1690
1691 thislen = strlen (normal);
a8da6403 1692 if (thislen > maxname || bfd_is_thin_archive (abfd))
252b5132
RH
1693 {
1694 /* Works for now; may need to be re-engineered if we
1695 encounter an oddball archive format and want to
d70910e8 1696 generalise this hack. */
252b5132 1697 struct ar_hdr *hdr = arch_hdr (current);
a8da6403
NC
1698 if (normal == last_filename)
1699 stroff = last_stroff;
3a11e31e
RM
1700 else
1701 {
a8da6403
NC
1702 strcpy (strptr, normal);
1703 if (! trailing_slash)
3a11e31e 1704 strptr[thislen] = ARFMAG[1];
a8da6403 1705 else
3a11e31e
RM
1706 {
1707 strptr[thislen] = '/';
1708 strptr[thislen + 1] = ARFMAG[1];
1709 }
a8da6403
NC
1710 stroff = strptr - *tabloc;
1711 last_stroff = stroff;
252b5132
RH
1712 }
1713 hdr->ar_name[0] = ar_padchar (current);
a8da6403
NC
1714 if (bfd_is_thin_archive (abfd) && current->origin > 0)
1715 {
1716 int len = snprintf (hdr->ar_name + 1, maxname - 1, "%-ld:",
3a11e31e 1717 stroff);
a8da6403 1718 _bfd_ar_spacepad (hdr->ar_name + 1 + len, maxname - 1 - len,
3a11e31e
RM
1719 "%-ld",
1720 current->origin - sizeof (struct ar_hdr));
a8da6403
NC
1721 }
1722 else
3a11e31e
RM
1723 _bfd_ar_spacepad (hdr->ar_name + 1, maxname - 1, "%-ld", stroff);
1724 if (normal != last_filename)
1725 {
a8da6403
NC
1726 strptr += thislen + 1;
1727 if (trailing_slash)
3a11e31e
RM
1728 ++strptr;
1729 last_filename = filename;
a8da6403 1730 }
252b5132
RH
1731 }
1732 }
1733
b34976b6 1734 return TRUE;
252b5132 1735}
8f95b6e4
TG
1736
1737/* Do not construct an extended name table but transforms name field into
1738 its extended form. */
1739
1740bfd_boolean
1741_bfd_archive_bsd44_construct_extended_name_table (bfd *abfd,
3a11e31e
RM
1742 char **tabloc,
1743 bfd_size_type *tablen,
1744 const char **name)
8f95b6e4 1745{
b228303d 1746 unsigned int maxname = ar_maxnamelen (abfd);
8f95b6e4
TG
1747 bfd *current;
1748
1749 *tablen = 0;
1750 *tabloc = NULL;
1751 *name = NULL;
1752
1753 for (current = abfd->archive_head;
1754 current != NULL;
1755 current = current->archive_next)
1756 {
1757 const char *normal = normalize (current, current->filename);
1758 int has_space = 0;
1759 unsigned int len;
1760
1761 if (normal == NULL)
1762 return FALSE;
1763
1764 for (len = 0; normal[len]; len++)
3a11e31e
RM
1765 if (normal[len] == ' ')
1766 has_space = 1;
8f95b6e4
TG
1767
1768 if (len > maxname || has_space)
1769 {
3a11e31e 1770 struct ar_hdr *hdr = arch_hdr (current);
8f95b6e4 1771
3a11e31e
RM
1772 len = (len + 3) & ~3;
1773 arch_eltdata (current)->extra_size = len;
1774 _bfd_ar_spacepad (hdr->ar_name, maxname, "#1/%lu", len);
8f95b6e4
TG
1775 }
1776 }
1777
1778 return TRUE;
1779}
1780\f
1781/* Write an archive header. */
1782
1783bfd_boolean
1784_bfd_generic_write_ar_hdr (bfd *archive, bfd *abfd)
1785{
1786 struct ar_hdr *hdr = arch_hdr (abfd);
1787
1788 if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
1789 return FALSE;
1790 return TRUE;
1791}
1792
1793/* Write an archive header using BSD4.4 convention. */
1794
1795bfd_boolean
1796_bfd_bsd44_write_ar_hdr (bfd *archive, bfd *abfd)
1797{
1798 struct ar_hdr *hdr = arch_hdr (abfd);
1799
1800 if (is_bsd44_extended_name (hdr->ar_name))
1801 {
1802 /* This is a BSD 4.4 extended name. */
1803 const char *fullname = normalize (abfd, abfd->filename);
1804 unsigned int len = strlen (fullname);
1805 unsigned int padded_len = (len + 3) & ~3;
1806
1807 BFD_ASSERT (padded_len == arch_eltdata (abfd)->extra_size);
1808
f1bb16f8 1809 if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size),
3a11e31e
RM
1810 arch_eltdata (abfd)->parsed_size + padded_len))
1811 return FALSE;
8f95b6e4
TG
1812
1813 if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
3a11e31e 1814 return FALSE;
8f95b6e4
TG
1815
1816 if (bfd_bwrite (fullname, len, archive) != len)
3a11e31e 1817 return FALSE;
f1bb16f8 1818
8f95b6e4 1819 if (len & 3)
3a11e31e
RM
1820 {
1821 static const char pad[3] = { 0, 0, 0 };
8f95b6e4 1822
3a11e31e
RM
1823 len = 4 - (len & 3);
1824 if (bfd_bwrite (pad, len, archive) != len)
1825 return FALSE;
1826 }
8f95b6e4
TG
1827 }
1828 else
1829 {
1830 if (bfd_bwrite (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
3a11e31e 1831 return FALSE;
8f95b6e4
TG
1832 }
1833 return TRUE;
1834}
252b5132 1835\f
06fc8a8c 1836/* A couple of functions for creating ar_hdrs. */
252b5132 1837
23afc6f6
JL
1838#ifdef HPUX_LARGE_AR_IDS
1839/* Function to encode large UID/GID values according to HP. */
047066e1 1840
23afc6f6 1841static void
c58b9523 1842hpux_uid_gid_encode (char str[6], long int id)
23afc6f6
JL
1843{
1844 int cnt;
1845
1846 str[5] = '@' + (id & 3);
1847 id >>= 2;
1848
174660ce 1849 for (cnt = 4; cnt >= 0; --cnt, id >>= 6)
23afc6f6
JL
1850 str[cnt] = ' ' + (id & 0x3f);
1851}
1852#endif /* HPUX_LARGE_AR_IDS */
1853
633fd09f
ILT
1854#ifndef HAVE_GETUID
1855#define getuid() 0
1856#endif
1857
1858#ifndef HAVE_GETGID
1859#define getgid() 0
1860#endif
1861
252b5132
RH
1862/* Takes a filename, returns an arelt_data for it, or NULL if it can't
1863 make one. The filename must refer to a filename in the filesystem.
1864 The filename field of the ar_hdr will NOT be initialized. If member
d70910e8 1865 is set, and it's an in-memory bfd, we fake it. */
252b5132
RH
1866
1867static struct areltdata *
c58b9523 1868bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
252b5132
RH
1869{
1870 struct stat status;
1871 struct areltdata *ared;
1872 struct ar_hdr *hdr;
dc810e39 1873 bfd_size_type amt;
252b5132
RH
1874
1875 if (member && (member->flags & BFD_IN_MEMORY) != 0)
1876 {
047066e1 1877 /* Assume we just "made" the member, and fake it. */
a50b1753 1878 struct bfd_in_memory *bim = (struct bfd_in_memory *) member->iostream;
047066e1
KH
1879 time (&status.st_mtime);
1880 status.st_uid = getuid ();
1881 status.st_gid = getgid ();
252b5132
RH
1882 status.st_mode = 0644;
1883 status.st_size = bim->size;
1884 }
1885 else if (stat (filename, &status) != 0)
1886 {
1887 bfd_set_error (bfd_error_system_call);
1888 return NULL;
1889 }
1890
36e4dce6
CD
1891 /* If the caller requested that the BFD generate deterministic output,
1892 fake values for modification time, UID, GID, and file mode. */
1893 if ((abfd->flags & BFD_DETERMINISTIC_OUTPUT) != 0)
1894 {
1895 status.st_mtime = 0;
1896 status.st_uid = 0;
1897 status.st_gid = 0;
1898 status.st_mode = 0644;
1899 }
1900
dc810e39 1901 amt = sizeof (struct ar_hdr) + sizeof (struct areltdata);
a50b1753 1902 ared = (struct areltdata *) bfd_zalloc (abfd, amt);
252b5132
RH
1903 if (ared == NULL)
1904 return NULL;
1905 hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));
1906
047066e1 1907 /* ar headers are space padded, not null padded! */
c58b9523 1908 memset (hdr, ' ', sizeof (struct ar_hdr));
252b5132 1909
390c0e42 1910 _bfd_ar_spacepad (hdr->ar_date, sizeof (hdr->ar_date), "%-12ld",
3a11e31e 1911 status.st_mtime);
23afc6f6
JL
1912#ifdef HPUX_LARGE_AR_IDS
1913 /* HP has a very "special" way to handle UID/GID's with numeric values
1914 > 99999. */
1915 if (status.st_uid > 99999)
390c0e42 1916 hpux_uid_gid_encode (hdr->ar_uid, (long) status.st_uid);
23afc6f6
JL
1917 else
1918#endif
390c0e42 1919 _bfd_ar_spacepad (hdr->ar_uid, sizeof (hdr->ar_uid), "%ld",
3a11e31e 1920 status.st_uid);
23afc6f6
JL
1921#ifdef HPUX_LARGE_AR_IDS
1922 /* HP has a very "special" way to handle UID/GID's with numeric values
1923 > 99999. */
1924 if (status.st_gid > 99999)
390c0e42 1925 hpux_uid_gid_encode (hdr->ar_gid, (long) status.st_gid);
23afc6f6
JL
1926 else
1927#endif
390c0e42 1928 _bfd_ar_spacepad (hdr->ar_gid, sizeof (hdr->ar_gid), "%ld",
3a11e31e 1929 status.st_gid);
390c0e42 1930 _bfd_ar_spacepad (hdr->ar_mode, sizeof (hdr->ar_mode), "%-8lo",
3a11e31e 1931 status.st_mode);
f1bb16f8
NC
1932 if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size), status.st_size))
1933 {
1934 free (ared);
1935 return NULL;
1936 }
390c0e42 1937 memcpy (hdr->ar_fmag, ARFMAG, 2);
252b5132
RH
1938 ared->parsed_size = status.st_size;
1939 ared->arch_header = (char *) hdr;
1940
1941 return ared;
1942}
1943
047066e1
KH
1944/* Analogous to stat call. */
1945
252b5132 1946int
c58b9523 1947bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
252b5132
RH
1948{
1949 struct ar_hdr *hdr;
1950 char *aloser;
1951
1952 if (abfd->arelt_data == NULL)
1953 {
1954 bfd_set_error (bfd_error_invalid_operation);
1955 return -1;
1956 }
1957
1958 hdr = arch_hdr (abfd);
1959
047066e1
KH
1960#define foo(arelt, stelt, size) \
1961 buf->stelt = strtol (hdr->arelt, &aloser, size); \
1962 if (aloser == hdr->arelt) \
1963 return -1;
1964
23afc6f6
JL
1965 /* Some platforms support special notations for large IDs. */
1966#ifdef HPUX_LARGE_AR_IDS
047066e1
KH
1967# define foo2(arelt, stelt, size) \
1968 if (hdr->arelt[5] == ' ') \
1969 { \
1970 foo (arelt, stelt, size); \
1971 } \
1972 else \
1973 { \
1974 int cnt; \
1975 for (buf->stelt = cnt = 0; cnt < 5; ++cnt) \
1976 { \
1977 if (hdr->arelt[cnt] < ' ' || hdr->arelt[cnt] > ' ' + 0x3f) \
1978 return -1; \
1979 buf->stelt <<= 6; \
1980 buf->stelt += hdr->arelt[cnt] - ' '; \
1981 } \
1982 if (hdr->arelt[5] < '@' || hdr->arelt[5] > '@' + 3) \
1983 return -1; \
1984 buf->stelt <<= 2; \
1985 buf->stelt += hdr->arelt[5] - '@'; \
1986 }
23afc6f6
JL
1987#else
1988# define foo2(arelt, stelt, size) foo (arelt, stelt, size)
1989#endif
252b5132
RH
1990
1991 foo (ar_date, st_mtime, 10);
23afc6f6
JL
1992 foo2 (ar_uid, st_uid, 10);
1993 foo2 (ar_gid, st_gid, 10);
252b5132
RH
1994 foo (ar_mode, st_mode, 8);
1995
1996 buf->st_size = arch_eltdata (abfd)->parsed_size;
1997
1998 return 0;
1999}
2000
2001void
c58b9523 2002bfd_dont_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
252b5132
RH
2003{
2004 /* FIXME: This interacts unpleasantly with ar's quick-append option.
2005 Fortunately ic960 users will never use that option. Fixing this
2006 is very hard; fortunately I know how to do it and will do so once
d70910e8 2007 intel's release is out the door. */
252b5132
RH
2008
2009 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
2010 size_t length;
2011 const char *filename;
2012 size_t maxlen = ar_maxnamelen (abfd);
2013
2014 if ((bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
2015 {
2016 bfd_bsd_truncate_arname (abfd, pathname, arhdr);
2017 return;
2018 }
2019
2020 filename = normalize (abfd, pathname);
2021 if (filename == NULL)
2022 {
2023 /* FIXME */
2024 abort ();
2025 }
2026
2027 length = strlen (filename);
2028
2029 if (length <= maxlen)
2030 memcpy (hdr->ar_name, filename, length);
2031
2032 /* Add the padding character if there is room for it. */
2033 if (length < maxlen
2034 || (length == maxlen && length < sizeof hdr->ar_name))
2035 (hdr->ar_name)[length] = ar_padchar (abfd);
2036}
2037
2038void
c58b9523 2039bfd_bsd_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
252b5132
RH
2040{
2041 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
dc810e39 2042 size_t length;
19172f39 2043 const char *filename = lbasename (pathname);
dc810e39 2044 size_t maxlen = ar_maxnamelen (abfd);
252b5132 2045
252b5132
RH
2046 length = strlen (filename);
2047
2048 if (length <= maxlen)
2049 memcpy (hdr->ar_name, filename, length);
2050 else
2051 {
2052 /* pathname: meet procrustes */
2053 memcpy (hdr->ar_name, filename, maxlen);
2054 length = maxlen;
2055 }
2056
2057 if (length < maxlen)
2058 (hdr->ar_name)[length] = ar_padchar (abfd);
2059}
2060
2061/* Store name into ar header. Truncates the name to fit.
2062 1> strip pathname to be just the basename.
2063 2> if it's short enuf to fit, stuff it in.
2064 3> If it doesn't end with .o, truncate it to fit
2065 4> truncate it before the .o, append .o, stuff THAT in. */
2066
2067/* This is what gnu ar does. It's better but incompatible with the
d70910e8 2068 bsd ar. */
252b5132
RH
2069
2070void
c58b9523 2071bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
252b5132
RH
2072{
2073 struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
dc810e39 2074 size_t length;
19172f39 2075 const char *filename = lbasename (pathname);
dc810e39 2076 size_t maxlen = ar_maxnamelen (abfd);
252b5132 2077
252b5132
RH
2078 length = strlen (filename);
2079
2080 if (length <= maxlen)
2081 memcpy (hdr->ar_name, filename, length);
2082 else
a8da6403
NC
2083 {
2084 /* pathname: meet procrustes. */
252b5132
RH
2085 memcpy (hdr->ar_name, filename, maxlen);
2086 if ((filename[length - 2] == '.') && (filename[length - 1] == 'o'))
2087 {
2088 hdr->ar_name[maxlen - 2] = '.';
2089 hdr->ar_name[maxlen - 1] = 'o';
2090 }
2091 length = maxlen;
2092 }
2093
2094 if (length < 16)
2095 (hdr->ar_name)[length] = ar_padchar (abfd);
2096}
2097\f
047066e1 2098/* The BFD is open for write and has its format set to bfd_archive. */
252b5132 2099
b34976b6 2100bfd_boolean
c58b9523 2101_bfd_write_archive_contents (bfd *arch)
252b5132
RH
2102{
2103 bfd *current;
2104 char *etable = NULL;
2105 bfd_size_type elength = 0;
2106 const char *ename = NULL;
b34976b6
AM
2107 bfd_boolean makemap = bfd_has_map (arch);
2108 /* If no .o's, don't bother to make a map. */
2109 bfd_boolean hasobjects = FALSE;
252b5132 2110 bfd_size_type wrote;
252b5132 2111 int tries;
a8da6403 2112 char *armag;
252b5132
RH
2113
2114 /* Verify the viability of all entries; if any of them live in the
2115 filesystem (as opposed to living in an archive open for input)
2116 then construct a fresh ar_hdr for them. */
cc481421
AM
2117 for (current = arch->archive_head;
2118 current != NULL;
2119 current = current->archive_next)
252b5132 2120 {
8000a618
DD
2121 /* This check is checking the bfds for the objects we're reading
2122 from (which are usually either an object file or archive on
2123 disk), not the archive entries we're writing to. We don't
2124 actually create bfds for the archive members, we just copy
2125 them byte-wise when we write out the archive. */
252b5132
RH
2126 if (bfd_write_p (current))
2127 {
2128 bfd_set_error (bfd_error_invalid_operation);
ffda70fc 2129 goto input_err;
252b5132
RH
2130 }
2131 if (!current->arelt_data)
2132 {
2133 current->arelt_data =
c58b9523 2134 bfd_ar_hdr_from_filesystem (arch, current->filename, current);
252b5132 2135 if (!current->arelt_data)
ffda70fc 2136 goto input_err;
252b5132 2137
047066e1 2138 /* Put in the file name. */
c58b9523
AM
2139 BFD_SEND (arch, _bfd_truncate_arname,
2140 (arch, current->filename, (char *) arch_hdr (current)));
252b5132
RH
2141 }
2142
2143 if (makemap && ! hasobjects)
047066e1 2144 { /* Don't bother if we won't make a map! */
0e71e495 2145 if ((bfd_check_format (current, bfd_object)))
b34976b6 2146 hasobjects = TRUE;
252b5132
RH
2147 }
2148 }
2149
2150 if (!BFD_SEND (arch, _bfd_construct_extended_name_table,
2151 (arch, &etable, &elength, &ename)))
b34976b6 2152 return FALSE;
252b5132
RH
2153
2154 if (bfd_seek (arch, (file_ptr) 0, SEEK_SET) != 0)
b34976b6 2155 return FALSE;
a8da6403
NC
2156 armag = ARMAG;
2157 if (bfd_is_thin_archive (arch))
2158 armag = ARMAGT;
2159 wrote = bfd_bwrite (armag, SARMAG, arch);
252b5132 2160 if (wrote != SARMAG)
b34976b6 2161 return FALSE;
252b5132
RH
2162
2163 if (makemap && hasobjects)
2164 {
82e51918 2165 if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength))
b34976b6 2166 return FALSE;
252b5132
RH
2167 }
2168
2169 if (elength != 0)
2170 {
2171 struct ar_hdr hdr;
2172
390c0e42
JJ
2173 memset (&hdr, ' ', sizeof (struct ar_hdr));
2174 memcpy (hdr.ar_name, ename, strlen (ename));
252b5132 2175 /* Round size up to even number in archive header. */
f1bb16f8 2176 if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size),
3a11e31e
RM
2177 (elength + 1) & ~(bfd_size_type) 1))
2178 return FALSE;
390c0e42 2179 memcpy (hdr.ar_fmag, ARFMAG, 2);
c58b9523 2180 if ((bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
252b5132 2181 != sizeof (struct ar_hdr))
dc810e39 2182 || bfd_bwrite (etable, elength, arch) != elength)
b34976b6 2183 return FALSE;
252b5132
RH
2184 if ((elength % 2) == 1)
2185 {
38d6ea5b 2186 if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)
b34976b6 2187 return FALSE;
252b5132
RH
2188 }
2189 }
2190
cc481421
AM
2191 for (current = arch->archive_head;
2192 current != NULL;
2193 current = current->archive_next)
252b5132
RH
2194 {
2195 char buffer[DEFAULT_BUFFERSIZE];
f1bb16f8 2196 bfd_size_type remaining = arelt_size (current);
252b5132 2197
047066e1 2198 /* Write ar header. */
8f95b6e4 2199 if (!_bfd_write_ar_hdr (arch, current))
3a11e31e 2200 return FALSE;
a8da6403 2201 if (bfd_is_thin_archive (arch))
3a11e31e 2202 continue;
252b5132 2203 if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0)
ffda70fc 2204 goto input_err;
a8da6403 2205
252b5132
RH
2206 while (remaining)
2207 {
2208 unsigned int amt = DEFAULT_BUFFERSIZE;
a8da6403 2209
252b5132
RH
2210 if (amt > remaining)
2211 amt = remaining;
2212 errno = 0;
c58b9523 2213 if (bfd_bread (buffer, amt, current) != amt)
252b5132
RH
2214 {
2215 if (bfd_get_error () != bfd_error_system_call)
ffda70fc
AM
2216 bfd_set_error (bfd_error_file_truncated);
2217 goto input_err;
252b5132 2218 }
c58b9523 2219 if (bfd_bwrite (buffer, amt, arch) != amt)
b34976b6 2220 return FALSE;
252b5132
RH
2221 remaining -= amt;
2222 }
a8da6403 2223
252b5132
RH
2224 if ((arelt_size (current) % 2) == 1)
2225 {
38d6ea5b 2226 if (bfd_bwrite (&ARFMAG[1], 1, arch) != 1)
b34976b6 2227 return FALSE;
252b5132
RH
2228 }
2229 }
2230
2231 if (makemap && hasobjects)
2232 {
2233 /* Verify the timestamp in the archive file. If it would not be
2234 accepted by the linker, rewrite it until it would be. If
2235 anything odd happens, break out and just return. (The
2236 Berkeley linker checks the timestamp and refuses to read the
2237 table-of-contents if it is >60 seconds less than the file's
2238 modified-time. That painful hack requires this painful hack. */
2239 tries = 1;
2240 do
2241 {
2242 if (bfd_update_armap_timestamp (arch))
2243 break;
2244 (*_bfd_error_handler)
2245 (_("Warning: writing archive was slow: rewriting timestamp\n"));
2246 }
2247 while (++tries < 6);
2248 }
2249
b34976b6 2250 return TRUE;
ffda70fc
AM
2251
2252 input_err:
2253 bfd_set_error (bfd_error_on_input, current, bfd_get_error ());
2254 return FALSE;
252b5132
RH
2255}
2256\f
047066e1 2257/* Note that the namidx for the first symbol is 0. */
252b5132 2258
b34976b6 2259bfd_boolean
c58b9523 2260_bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
252b5132
RH
2261{
2262 char *first_name = NULL;
2263 bfd *current;
2264 file_ptr elt_no = 0;
2265 struct orl *map = NULL;
06fc8a8c 2266 unsigned int orl_max = 1024; /* Fine initial default. */
dc810e39 2267 unsigned int orl_count = 0;
06fc8a8c 2268 int stridx = 0;
252b5132
RH
2269 asymbol **syms = NULL;
2270 long syms_max = 0;
b34976b6 2271 bfd_boolean ret;
dc810e39 2272 bfd_size_type amt;
252b5132 2273
d70910e8 2274 /* Dunno if this is the best place for this info... */
252b5132
RH
2275 if (elength != 0)
2276 elength += sizeof (struct ar_hdr);
2277 elength += elength % 2;
2278
c58b9523 2279 amt = orl_max * sizeof (struct orl);
a50b1753 2280 map = (struct orl *) bfd_malloc (amt);
252b5132
RH
2281 if (map == NULL)
2282 goto error_return;
2283
2284 /* We put the symbol names on the arch objalloc, and then discard
2285 them when done. */
a50b1753 2286 first_name = (char *) bfd_alloc (arch, 1);
252b5132
RH
2287 if (first_name == NULL)
2288 goto error_return;
2289
047066e1 2290 /* Drop all the files called __.SYMDEF, we're going to make our own. */
a8da6403
NC
2291 while (arch->archive_head
2292 && strcmp (arch->archive_head->filename, "__.SYMDEF") == 0)
cc481421 2293 arch->archive_head = arch->archive_head->archive_next;
252b5132 2294
047066e1 2295 /* Map over each element. */
252b5132 2296 for (current = arch->archive_head;
c58b9523 2297 current != NULL;
cc481421 2298 current = current->archive_next, elt_no++)
252b5132 2299 {
82e51918
AM
2300 if (bfd_check_format (current, bfd_object)
2301 && (bfd_get_file_flags (current) & HAS_SYMS) != 0)
252b5132
RH
2302 {
2303 long storage;
2304 long symcount;
2305 long src_count;
2306
2307 storage = bfd_get_symtab_upper_bound (current);
2308 if (storage < 0)
2309 goto error_return;
2310
2311 if (storage != 0)
2312 {
2313 if (storage > syms_max)
2314 {
2315 if (syms_max > 0)
2316 free (syms);
2317 syms_max = storage;
a50b1753 2318 syms = (asymbol **) bfd_malloc (syms_max);
252b5132
RH
2319 if (syms == NULL)
2320 goto error_return;
2321 }
2322 symcount = bfd_canonicalize_symtab (current, syms);
2323 if (symcount < 0)
2324 goto error_return;
2325
047066e1 2326 /* Now map over all the symbols, picking out the ones we
3a11e31e 2327 want. */
252b5132
RH
2328 for (src_count = 0; src_count < symcount; src_count++)
2329 {
2330 flagword flags = (syms[src_count])->flags;
2331 asection *sec = syms[src_count]->section;
2332
d5abbdf3
L
2333 if (((flags & (BSF_GLOBAL
2334 | BSF_WEAK
2335 | BSF_INDIRECT
2336 | BSF_GNU_UNIQUE)) != 0
a8da6403 2337 || bfd_is_com_section (sec))
77fb9c28 2338 && ! bfd_is_und_section (sec))
252b5132 2339 {
dc810e39 2340 bfd_size_type namelen;
77fb9c28
NC
2341 struct orl *new_map;
2342
047066e1 2343 /* This symbol will go into the archive header. */
252b5132
RH
2344 if (orl_count == orl_max)
2345 {
2346 orl_max *= 2;
c58b9523 2347 amt = orl_max * sizeof (struct orl);
a50b1753 2348 new_map = (struct orl *) bfd_realloc (map, amt);
c58b9523 2349 if (new_map == NULL)
252b5132
RH
2350 goto error_return;
2351
2352 map = new_map;
2353 }
2354
2355 namelen = strlen (syms[src_count]->name);
dc810e39 2356 amt = sizeof (char *);
a50b1753 2357 map[orl_count].name = (char **) bfd_alloc (arch, amt);
252b5132
RH
2358 if (map[orl_count].name == NULL)
2359 goto error_return;
a50b1753 2360 *(map[orl_count].name) = (char *) bfd_alloc (arch,
3a11e31e 2361 namelen + 1);
252b5132
RH
2362 if (*(map[orl_count].name) == NULL)
2363 goto error_return;
2364 strcpy (*(map[orl_count].name), syms[src_count]->name);
dc810e39
AM
2365 map[orl_count].u.abfd = current;
2366 map[orl_count].namidx = stridx;
252b5132
RH
2367
2368 stridx += namelen + 1;
2369 ++orl_count;
77fb9c28 2370 }
252b5132
RH
2371 }
2372 }
2373
2374 /* Now ask the BFD to free up any cached information, so we
2375 don't fill all of memory with symbol tables. */
2376 if (! bfd_free_cached_info (current))
2377 goto error_return;
2378 }
2379 }
2380
047066e1 2381 /* OK, now we have collected all the data, let's write them out. */
252b5132
RH
2382 ret = BFD_SEND (arch, write_armap,
2383 (arch, elength, map, orl_count, stridx));
2384
2385 if (syms_max > 0)
2386 free (syms);
2387 if (map != NULL)
2388 free (map);
2389 if (first_name != NULL)
2390 bfd_release (arch, first_name);
2391
2392 return ret;
2393
2394 error_return:
2395 if (syms_max > 0)
2396 free (syms);
2397 if (map != NULL)
2398 free (map);
2399 if (first_name != NULL)
2400 bfd_release (arch, first_name);
2401
b34976b6 2402 return FALSE;
252b5132
RH
2403}
2404
b34976b6 2405bfd_boolean
c58b9523
AM
2406bsd_write_armap (bfd *arch,
2407 unsigned int elength,
2408 struct orl *map,
2409 unsigned int orl_count,
2410 int stridx)
252b5132
RH
2411{
2412 int padit = stridx & 1;
2413 unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE;
2414 unsigned int stringsize = stridx + padit;
d70910e8 2415 /* Include 8 bytes to store ranlibsize and stringsize in output. */
252b5132
RH
2416 unsigned int mapsize = ranlibsize + stringsize + 8;
2417 file_ptr firstreal;
2418 bfd *current = arch->archive_head;
06fc8a8c 2419 bfd *last_elt = current; /* Last element arch seen. */
252b5132
RH
2420 bfd_byte temp[4];
2421 unsigned int count;
2422 struct ar_hdr hdr;
36e4dce6 2423 long uid, gid;
5f8ebec5
NC
2424 file_ptr max_first_real = 1;
2425
2426 max_first_real <<= 31;
252b5132
RH
2427
2428 firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
2429
0e29e6e8
AM
2430 /* If deterministic, we use 0 as the timestamp in the map.
2431 Some linkers may require that the archive filesystem modification
2432 time is less than (or near to) the archive map timestamp. Those
2433 linkers should not be used with deterministic mode. (GNU ld and
2434 Gold do not have this restriction.) */
2435 bfd_ardata (arch)->armap_timestamp = 0;
2436 uid = 0;
2437 gid = 0;
36e4dce6
CD
2438 if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0)
2439 {
0e29e6e8
AM
2440 struct stat statbuf;
2441
2442 if (stat (arch->filename, &statbuf) == 0)
2443 bfd_ardata (arch)->armap_timestamp = (statbuf.st_mtime
2444 + ARMAP_TIME_OFFSET);
36e4dce6
CD
2445 uid = getuid();
2446 gid = getgid();
2447 }
36e4dce6 2448
390c0e42
JJ
2449 memset (&hdr, ' ', sizeof (struct ar_hdr));
2450 memcpy (hdr.ar_name, RANLIBMAG, strlen (RANLIBMAG));
252b5132
RH
2451 bfd_ardata (arch)->armap_datepos = (SARMAG
2452 + offsetof (struct ar_hdr, ar_date[0]));
390c0e42 2453 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
3a11e31e 2454 bfd_ardata (arch)->armap_timestamp);
36e4dce6
CD
2455 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", uid);
2456 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", gid);
f1bb16f8
NC
2457 if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))
2458 return FALSE;
390c0e42 2459 memcpy (hdr.ar_fmag, ARFMAG, 2);
c58b9523 2460 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
252b5132 2461 != sizeof (struct ar_hdr))
b34976b6 2462 return FALSE;
dc810e39 2463 H_PUT_32 (arch, ranlibsize, temp);
c58b9523 2464 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
b34976b6 2465 return FALSE;
252b5132
RH
2466
2467 for (count = 0; count < orl_count; count++)
2468 {
2469 bfd_byte buf[BSD_SYMDEF_SIZE];
2470
dc810e39 2471 if (map[count].u.abfd != last_elt)
252b5132
RH
2472 {
2473 do
2474 {
3a11e31e 2475 struct areltdata *ared = arch_eltdata (current);
8f95b6e4
TG
2476
2477 firstreal += (ared->parsed_size + ared->extra_size
3a11e31e 2478 + sizeof (struct ar_hdr));
252b5132 2479 firstreal += firstreal % 2;
cc481421 2480 current = current->archive_next;
252b5132 2481 }
dc810e39 2482 while (current != map[count].u.abfd);
06fc8a8c 2483 }
252b5132 2484
5f8ebec5
NC
2485 /* The archive file format only has 4 bytes to store the offset
2486 of the member. Check to make sure that firstreal has not grown
2487 too big. */
2488 if (firstreal >= max_first_real)
2489 {
2490 bfd_set_error (bfd_error_file_truncated);
2491 return FALSE;
2492 }
2493
252b5132 2494 last_elt = current;
dc810e39
AM
2495 H_PUT_32 (arch, map[count].namidx, buf);
2496 H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE);
c58b9523 2497 if (bfd_bwrite (buf, BSD_SYMDEF_SIZE, arch)
dc810e39 2498 != BSD_SYMDEF_SIZE)
b34976b6 2499 return FALSE;
252b5132
RH
2500 }
2501
047066e1 2502 /* Now write the strings themselves. */
dc810e39 2503 H_PUT_32 (arch, stringsize, temp);
c58b9523 2504 if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp))
b34976b6 2505 return FALSE;
252b5132
RH
2506 for (count = 0; count < orl_count; count++)
2507 {
2508 size_t len = strlen (*map[count].name) + 1;
2509
c58b9523 2510 if (bfd_bwrite (*map[count].name, len, arch) != len)
b34976b6 2511 return FALSE;
252b5132
RH
2512 }
2513
2514 /* The spec sez this should be a newline. But in order to be
d70910e8 2515 bug-compatible for sun's ar we use a null. */
252b5132
RH
2516 if (padit)
2517 {
c58b9523 2518 if (bfd_bwrite ("", 1, arch) != 1)
b34976b6 2519 return FALSE;
252b5132
RH
2520 }
2521
b34976b6 2522 return TRUE;
252b5132
RH
2523}
2524
2525/* At the end of archive file handling, update the timestamp in the
2526 file, so the linker will accept it.
2527
b34976b6
AM
2528 Return TRUE if the timestamp was OK, or an unusual problem happened.
2529 Return FALSE if we updated the timestamp. */
252b5132 2530
b34976b6 2531bfd_boolean
c58b9523 2532_bfd_archive_bsd_update_armap_timestamp (bfd *arch)
252b5132
RH
2533{
2534 struct stat archstat;
2535 struct ar_hdr hdr;
252b5132 2536
36e4dce6
CD
2537 /* If creating deterministic archives, just leave the timestamp as-is. */
2538 if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) != 0)
2539 return TRUE;
2540
252b5132
RH
2541 /* Flush writes, get last-write timestamp from file, and compare it
2542 to the timestamp IN the file. */
2543 bfd_flush (arch);
2544 if (bfd_stat (arch, &archstat) == -1)
2545 {
5fe39cae 2546 bfd_perror (_("Reading archive file mod timestamp"));
047066e1
KH
2547
2548 /* Can't read mod time for some reason. */
b34976b6 2549 return TRUE;
252b5132 2550 }
ae38509c 2551 if (((long) archstat.st_mtime) <= bfd_ardata (arch)->armap_timestamp)
047066e1 2552 /* OK by the linker's rules. */
b34976b6 2553 return TRUE;
252b5132
RH
2554
2555 /* Update the timestamp. */
2556 bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET;
2557
2558 /* Prepare an ASCII version suitable for writing. */
390c0e42
JJ
2559 memset (hdr.ar_date, ' ', sizeof (hdr.ar_date));
2560 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
3a11e31e 2561 bfd_ardata (arch)->armap_timestamp);
252b5132
RH
2562
2563 /* Write it into the file. */
2564 bfd_ardata (arch)->armap_datepos = (SARMAG
2565 + offsetof (struct ar_hdr, ar_date[0]));
2566 if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0
c58b9523 2567 || (bfd_bwrite (hdr.ar_date, sizeof (hdr.ar_date), arch)
252b5132
RH
2568 != sizeof (hdr.ar_date)))
2569 {
5fe39cae 2570 bfd_perror (_("Writing updated armap timestamp"));
047066e1
KH
2571
2572 /* Some error while writing. */
b34976b6 2573 return TRUE;
252b5132
RH
2574 }
2575
047066e1 2576 /* We updated the timestamp successfully. */
b34976b6 2577 return FALSE;
252b5132
RH
2578}
2579\f
2580/* A coff armap looks like :
2581 lARMAG
2582 struct ar_hdr with name = '/'
2583 number of symbols
2584 offset of file for symbol 0
2585 offset of file for symbol 1
2586
2587 offset of file for symbol n-1
2588 symbol name 0
2589 symbol name 1
2590
06fc8a8c 2591 symbol name n-1 */
252b5132 2592
b34976b6 2593bfd_boolean
c58b9523
AM
2594coff_write_armap (bfd *arch,
2595 unsigned int elength,
2596 struct orl *map,
2597 unsigned int symbol_count,
2598 int stridx)
252b5132
RH
2599{
2600 /* The size of the ranlib is the number of exported symbols in the
08da05b0 2601 archive * the number of bytes in an int, + an int for the count. */
252b5132
RH
2602 unsigned int ranlibsize = (symbol_count * 4) + 4;
2603 unsigned int stringsize = stridx;
2604 unsigned int mapsize = stringsize + ranlibsize;
5f8ebec5 2605 file_ptr archive_member_file_ptr;
252b5132
RH
2606 bfd *current = arch->archive_head;
2607 unsigned int count;
2608 struct ar_hdr hdr;
252b5132
RH
2609 int padit = mapsize & 1;
2610
2611 if (padit)
2612 mapsize++;
2613
047066e1 2614 /* Work out where the first object file will go in the archive. */
252b5132
RH
2615 archive_member_file_ptr = (mapsize
2616 + elength
2617 + sizeof (struct ar_hdr)
2618 + SARMAG);
2619
390c0e42 2620 memset (&hdr, ' ', sizeof (struct ar_hdr));
252b5132 2621 hdr.ar_name[0] = '/';
f1bb16f8
NC
2622 if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))
2623 return FALSE;
390c0e42 2624 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
3a11e31e
RM
2625 ((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0
2626 ? time (NULL) : 0));
047066e1 2627 /* This, at least, is what Intel coff sets the values to. */
390c0e42
JJ
2628 _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", 0);
2629 _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", 0);
2630 _bfd_ar_spacepad (hdr.ar_mode, sizeof (hdr.ar_mode), "%-7lo", 0);
2631 memcpy (hdr.ar_fmag, ARFMAG, 2);
252b5132 2632
047066e1 2633 /* Write the ar header for this item and the number of symbols. */
c58b9523 2634 if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
252b5132 2635 != sizeof (struct ar_hdr))
b34976b6 2636 return FALSE;
252b5132 2637
4dae1ae7 2638 if (!bfd_write_bigendian_4byte_int (arch, symbol_count))
b34976b6 2639 return FALSE;
252b5132
RH
2640
2641 /* Two passes, first write the file offsets for each symbol -
2642 remembering that each offset is on a two byte boundary. */
2643
2644 /* Write out the file offset for the file associated with each
2645 symbol, and remember to keep the offsets padded out. */
2646
2647 current = arch->archive_head;
2648 count = 0;
c58b9523 2649 while (current != NULL && count < symbol_count)
252b5132 2650 {
047066e1
KH
2651 /* For each symbol which is used defined in this object, write
2652 out the object file's address in the archive. */
252b5132 2653
dc810e39 2654 while (count < symbol_count && map[count].u.abfd == current)
252b5132 2655 {
5f8ebec5
NC
2656 unsigned int offset = (unsigned int) archive_member_file_ptr;
2657
2658 /* Catch an attempt to grow an archive past its 4Gb limit. */
2659 if (archive_member_file_ptr != (file_ptr) offset)
2660 {
2661 bfd_set_error (bfd_error_file_truncated);
2662 return FALSE;
2663 }
2664 if (!bfd_write_bigendian_4byte_int (arch, offset))
b34976b6 2665 return FALSE;
252b5132
RH
2666 count++;
2667 }
a8da6403
NC
2668 archive_member_file_ptr += sizeof (struct ar_hdr);
2669 if (! bfd_is_thin_archive (arch))
3a11e31e
RM
2670 {
2671 /* Add size of this archive entry. */
2672 archive_member_file_ptr += arelt_size (current);
2673 /* Remember about the even alignment. */
2674 archive_member_file_ptr += archive_member_file_ptr % 2;
2675 }
cc481421 2676 current = current->archive_next;
252b5132
RH
2677 }
2678
047066e1 2679 /* Now write the strings themselves. */
252b5132
RH
2680 for (count = 0; count < symbol_count; count++)
2681 {
2682 size_t len = strlen (*map[count].name) + 1;
2683
c58b9523 2684 if (bfd_bwrite (*map[count].name, len, arch) != len)
b34976b6 2685 return FALSE;
252b5132
RH
2686 }
2687
2688 /* The spec sez this should be a newline. But in order to be
d70910e8 2689 bug-compatible for arc960 we use a null. */
252b5132
RH
2690 if (padit)
2691 {
c58b9523 2692 if (bfd_bwrite ("", 1, arch) != 1)
b34976b6 2693 return FALSE;
252b5132
RH
2694 }
2695
b34976b6 2696 return TRUE;
252b5132 2697}
This page took 1.561063 seconds and 4 git commands to generate.