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