X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Farchive.c;h=3423a336956a211eb707d0f2bff724e52ca6b12c;hb=dc7148375d70a95aa66328276a08a50914482aef;hp=fe57755770bbbfc43be705fb5c437dd8619dff7d;hpb=2c3fc38946973ec305b63248abdd170eda059f80;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/archive.c b/bfd/archive.c index fe57755770..3423a33695 100644 --- a/bfd/archive.c +++ b/bfd/archive.c @@ -1,7 +1,5 @@ /* BFD back-end for archive files (libraries). - Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, - 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, - 2012 Free Software Foundation, Inc. + Copyright (C) 1990-2020 Free Software Foundation, Inc. Written by Cygnus Support. Mostly Gumby Henkel-Wallace's fault. This file is part of BFD, the Binary File Descriptor library. @@ -42,11 +40,17 @@ DESCRIPTION have to read the entire archive if you don't want to! Read it until you find what you want. + A BFD returned by <> can be + closed manually with <>. If you do not close it, + then a second iteration through the members of an archive may + return the same BFD. If you close the archive BFD, then all + the member BFDs will automatically be closed as well. + Archive contents of output BFDs are chained through the - <> pointer in a BFD. The first one is findable through - the <> slot of the archive. Set it with - <> (q.v.). A given BFD may be in only one - open output archive at a time. + <> pointer in a BFD. The first one is findable + through the <> slot of the archive. Set it with + <> (q.v.). A given BFD may be in only + one open output archive at a time. As expected, the BFD archive code is more general than the archive code of any given environment. BFD archives may @@ -136,6 +140,7 @@ SUBSECTION #include "safe-ctype.h" #include "hashtab.h" #include "filenames.h" +#include "bfdlink.h" #ifndef errno extern int errno; @@ -207,7 +212,7 @@ _bfd_ar_sizepad (char *p, size_t n, bfd_size_type size) bfd_boolean _bfd_generic_mkarchive (bfd *abfd) { - bfd_size_type amt = sizeof (struct artdata); + size_t amt = sizeof (struct artdata); abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc (abfd, amt); if (bfd_ardata (abfd) == NULL) @@ -306,8 +311,12 @@ _bfd_look_for_bfd_in_cache (bfd *arch_bfd, file_ptr filepos) struct ar_cache *entry = (struct ar_cache *) htab_find (hash_table, &m); if (!entry) return NULL; - else - return entry->arbfd; + + /* Unfortunately this flag is set after checking that we have + an archive, and checking for an archive means one element has + sneaked into the cache. */ + entry->arbfd->no_export = arch_bfd->no_export; + return entry->arbfd; } else return NULL; @@ -362,14 +371,43 @@ _bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt) cache->arbfd = new_elt; *htab_find_slot (hash_table, (const void *) cache, INSERT) = cache; + /* Provide a means of accessing this from child. */ + arch_eltdata (new_elt)->parent_cache = hash_table; + arch_eltdata (new_elt)->key = filepos; + return TRUE; } static bfd * -_bfd_find_nested_archive (bfd *arch_bfd, const char *filename) +open_nested_file (const char *filename, bfd *archive) { - bfd *abfd; const char *target; + bfd *n_bfd; + + target = NULL; + if (!archive->target_defaulted) + target = archive->xvec->name; + n_bfd = bfd_openr (filename, target); + if (n_bfd != NULL) + { + n_bfd->lto_output = archive->lto_output; + n_bfd->no_export = archive->no_export; + n_bfd->my_archive = archive; + } + return n_bfd; +} + +static bfd * +find_nested_archive (const char *filename, bfd *arch_bfd) +{ + bfd *abfd; + + /* PR 15140: Don't allow a nested archive pointing to itself. */ + if (filename_cmp (filename, arch_bfd->filename) == 0) + { + bfd_set_error (bfd_error_malformed_archive); + return NULL; + } for (abfd = arch_bfd->nested_archives; abfd != NULL; @@ -378,10 +416,7 @@ _bfd_find_nested_archive (bfd *arch_bfd, const char *filename) if (filename_cmp (filename, abfd->filename) == 0) return abfd; } - target = NULL; - if (!arch_bfd->target_defaulted) - target = arch_bfd->xvec->name; - abfd = bfd_openr (filename, target); + abfd = open_nested_file (filename, arch_bfd); if (abfd) { abfd->archive_next = arch_bfd->nested_archives; @@ -453,6 +488,7 @@ _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag) bfd_size_type parsed_size; struct areltdata *ared; char *filename = NULL; + ufile_ptr filesize; bfd_size_type namelen = 0; bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr); char *allocptr = 0; @@ -503,11 +539,19 @@ _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag) { /* BSD-4.4 extended name */ namelen = atoi (&hdr.ar_name[3]); + filesize = bfd_get_file_size (abfd); + if (namelen > parsed_size + || namelen > -allocsize - 2 + || (filesize != 0 && namelen > filesize)) + { + bfd_set_error (bfd_error_malformed_archive); + return NULL; + } allocsize += namelen + 1; parsed_size -= namelen; extra_size = namelen; - allocptr = (char *) bfd_zalloc (abfd, allocsize); + allocptr = (char *) bfd_malloc (allocsize); if (allocptr == NULL) return NULL; filename = (allocptr @@ -515,6 +559,7 @@ _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag) + sizeof (struct ar_hdr)); if (bfd_bread (filename, namelen, abfd) != namelen) { + free (allocptr); if (bfd_get_error () != bfd_error_system_call) bfd_set_error (bfd_error_no_more_archived_files); return NULL; @@ -550,13 +595,13 @@ _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag) if (!allocptr) { - allocptr = (char *) bfd_zalloc (abfd, allocsize); + allocptr = (char *) bfd_malloc (allocsize); if (allocptr == NULL) return NULL; } + memset (allocptr, 0, sizeof (struct areltdata)); ared = (struct areltdata *) allocptr; - ared->arch_header = allocptr + sizeof (struct areltdata); memcpy (ared->arch_header, &hdr, sizeof (struct ar_hdr)); ared->parsed_size = parsed_size; @@ -609,12 +654,12 @@ bfd * _bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos) { struct areltdata *new_areldata; - bfd *n_nfd; + bfd *n_bfd; char *filename; - n_nfd = _bfd_look_for_bfd_in_cache (archive, filepos); - if (n_nfd) - return n_nfd; + n_bfd = _bfd_look_for_bfd_in_cache (archive, filepos); + if (n_bfd) + return n_bfd; if (0 > bfd_seek (archive, filepos, SEEK_SET)) return NULL; @@ -626,78 +671,95 @@ _bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos) if (bfd_is_thin_archive (archive)) { - const char *target; - /* This is a proxy entry for an external file. */ if (! IS_ABSOLUTE_PATH (filename)) { filename = _bfd_append_relative_path (archive, filename); if (filename == NULL) - return NULL; + { + free (new_areldata); + return NULL; + } } if (new_areldata->origin > 0) { /* This proxy entry refers to an element of a nested archive. Locate the member of that archive and return a bfd for it. */ - bfd *ext_arch = _bfd_find_nested_archive (archive, filename); + bfd *ext_arch = find_nested_archive (filename, archive); if (ext_arch == NULL || ! bfd_check_format (ext_arch, bfd_archive)) { - bfd_release (archive, new_areldata); + free (new_areldata); return NULL; } - n_nfd = _bfd_get_elt_at_filepos (ext_arch, new_areldata->origin); - if (n_nfd == NULL) + n_bfd = _bfd_get_elt_at_filepos (ext_arch, new_areldata->origin); + if (n_bfd == NULL) { - bfd_release (archive, new_areldata); + free (new_areldata); return NULL; } - n_nfd->proxy_origin = bfd_tell (archive); - return n_nfd; + n_bfd->proxy_origin = bfd_tell (archive); + + /* Copy BFD_COMPRESS, BFD_DECOMPRESS and BFD_COMPRESS_GABI + flags. */ + n_bfd->flags |= archive->flags & (BFD_COMPRESS + | BFD_DECOMPRESS + | BFD_COMPRESS_GABI); + + return n_bfd; } + /* It's not an element of a nested archive; open the external file as a bfd. */ - target = NULL; - if (!archive->target_defaulted) - target = archive->xvec->name; - n_nfd = bfd_openr (filename, target); - if (n_nfd == NULL) + n_bfd = open_nested_file (filename, archive); + if (n_bfd == NULL) bfd_set_error (bfd_error_malformed_archive); } else { - n_nfd = _bfd_create_empty_archive_element_shell (archive); + n_bfd = _bfd_create_empty_archive_element_shell (archive); } - if (n_nfd == NULL) + if (n_bfd == NULL) { - bfd_release (archive, new_areldata); + free (new_areldata); return NULL; } - n_nfd->proxy_origin = bfd_tell (archive); + n_bfd->proxy_origin = bfd_tell (archive); if (bfd_is_thin_archive (archive)) { - n_nfd->origin = 0; + n_bfd->origin = 0; } else { - n_nfd->origin = n_nfd->proxy_origin; - n_nfd->filename = filename; + n_bfd->origin = n_bfd->proxy_origin; + n_bfd->filename = bfd_strdup (filename); + if (n_bfd->filename == NULL) + goto out; } - n_nfd->arelt_data = new_areldata; + n_bfd->arelt_data = new_areldata; + + /* Copy BFD_COMPRESS, BFD_DECOMPRESS and BFD_COMPRESS_GABI flags. */ + n_bfd->flags |= archive->flags & (BFD_COMPRESS + | BFD_DECOMPRESS + | BFD_COMPRESS_GABI); - /* Copy BFD_COMPRESS and BFD_DECOMPRESS flags. */ - n_nfd->flags |= archive->flags & (BFD_COMPRESS | BFD_DECOMPRESS); + /* Copy is_linker_input. */ + n_bfd->is_linker_input = archive->is_linker_input; - if (_bfd_add_bfd_to_archive_cache (archive, filepos, n_nfd)) - return n_nfd; + if (archive->no_element_cache + || _bfd_add_bfd_to_archive_cache (archive, filepos, n_bfd)) + return n_bfd; - bfd_release (archive, new_areldata); + out: + free (new_areldata); + n_bfd->arelt_data = NULL; + bfd_close (n_bfd); return NULL; } @@ -713,6 +775,13 @@ _bfd_generic_get_elt_at_index (bfd *abfd, symindex sym_index) return _bfd_get_elt_at_filepos (abfd, entry->file_offset); } +bfd * +_bfd_noarchive_get_elt_at_index (bfd *abfd, + symindex sym_index ATTRIBUTE_UNUSED) +{ + return (bfd *) _bfd_ptr_bfd_null_error (abfd); +} + /* FUNCTION bfd_openr_next_archived_file @@ -723,10 +792,11 @@ SYNOPSIS DESCRIPTION Provided a BFD, @var{archive}, containing an archive and NULL, open an input BFD on the first contained element and returns that. - Subsequent calls should pass - the archive and the previous return value to return a created - BFD to the next contained element. NULL is returned when there - are no more. + Subsequent calls should pass the archive and the previous return + value to return a created BFD to the next contained element. NULL + is returned when there are no more. + Note - if you want to process the bfd returned by this call be + sure to call bfd_check_format() on it first. */ bfd * @@ -746,32 +816,47 @@ bfd_openr_next_archived_file (bfd *archive, bfd *last_file) bfd * bfd_generic_openr_next_archived_file (bfd *archive, bfd *last_file) { - file_ptr filestart; + ufile_ptr filestart; if (!last_file) filestart = bfd_ardata (archive)->first_file_filepos; else { - bfd_size_type size = arelt_size (last_file); - filestart = last_file->proxy_origin; if (! bfd_is_thin_archive (archive)) - filestart += size; - /* Pad to an even boundary... - Note that last_file->origin can be odd in the case of - BSD-4.4-style element with a long odd size. */ - filestart += filestart % 2; + { + bfd_size_type size = arelt_size (last_file); + + filestart += size; + /* Pad to an even boundary... + Note that last_file->origin can be odd in the case of + BSD-4.4-style element with a long odd size. */ + filestart += filestart % 2; + if (filestart < last_file->proxy_origin) + { + /* Prevent looping. See PR19256. */ + bfd_set_error (bfd_error_malformed_archive); + return NULL; + } + } } return _bfd_get_elt_at_filepos (archive, filestart); } -const bfd_target * +bfd * +_bfd_noarchive_openr_next_archived_file (bfd *archive, + bfd *last_file ATTRIBUTE_UNUSED) +{ + return (bfd *) _bfd_ptr_bfd_null_error (archive); +} + +bfd_cleanup bfd_generic_archive_p (bfd *abfd) { struct artdata *tdata_hold; char armag[SARMAG + 1]; - bfd_size_type amt; + size_t amt; if (bfd_bread (armag, SARMAG, abfd) != SARMAG) { @@ -780,12 +865,14 @@ bfd_generic_archive_p (bfd *abfd) return NULL; } - bfd_is_thin_archive (abfd) = (strncmp (armag, ARMAGT, SARMAG) == 0); + bfd_set_thin_archive (abfd, strncmp (armag, ARMAGT, SARMAG) == 0); if (strncmp (armag, ARMAG, SARMAG) != 0 - && strncmp (armag, ARMAGB, SARMAG) != 0 && ! bfd_is_thin_archive (abfd)) - return NULL; + { + bfd_set_error (bfd_error_wrong_format); + return NULL; + } tdata_hold = bfd_ardata (abfd); @@ -819,6 +906,7 @@ bfd_generic_archive_p (bfd *abfd) if (abfd->target_defaulted && bfd_has_map (abfd)) { bfd *first; + unsigned int save; /* This archive has a map, so we may presume that the contents are object files. Make sure that if the first file in the @@ -831,22 +919,21 @@ bfd_generic_archive_p (bfd *abfd) normal archive, regardless of the format of the object files. We do accept an empty archive. */ + save = abfd->no_element_cache; + abfd->no_element_cache = 1; first = bfd_openr_next_archived_file (abfd, NULL); + abfd->no_element_cache = save; if (first != NULL) { first->target_defaulted = FALSE; if (bfd_check_format (first, bfd_object) && first->xvec != abfd->xvec) - { - bfd_set_error (bfd_error_wrong_object_format); - bfd_ardata (abfd) = tdata_hold; - return NULL; - } - /* And we ought to close `first' here too. */ + bfd_set_error (bfd_error_wrong_object_format); + bfd_close (first); } } - return abfd->xvec; + return _bfd_no_cleanup; } /* Some constants for a 32 bit BSD archive structure. We do not @@ -873,57 +960,66 @@ static bfd_boolean do_slurp_bsd_armap (bfd *abfd) { struct areltdata *mapdata; - unsigned int counter; + size_t counter; bfd_byte *raw_armap, *rbase; struct artdata *ardata = bfd_ardata (abfd); char *stringbase; - bfd_size_type parsed_size, amt; + bfd_size_type parsed_size; + size_t amt, string_size; carsym *set; mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd); if (mapdata == NULL) return FALSE; parsed_size = mapdata->parsed_size; - bfd_release (abfd, mapdata); /* Don't need it any more. */ - - raw_armap = (bfd_byte *) bfd_zalloc (abfd, parsed_size); - if (raw_armap == NULL) - return FALSE; - - if (bfd_bread (raw_armap, parsed_size, abfd) != parsed_size) + free (mapdata); + /* PR 17512: file: 883ff754. */ + /* PR 17512: file: 0458885f. */ + if (parsed_size < BSD_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE) { - if (bfd_get_error () != bfd_error_system_call) - bfd_set_error (bfd_error_malformed_archive); - byebye: - bfd_release (abfd, raw_armap); + bfd_set_error (bfd_error_malformed_archive); return FALSE; } - ardata->symdef_count = H_GET_32 (abfd, raw_armap) / BSD_SYMDEF_SIZE; + raw_armap = (bfd_byte *) _bfd_alloc_and_read (abfd, parsed_size, parsed_size); + if (raw_armap == NULL) + return FALSE; - if (ardata->symdef_count * BSD_SYMDEF_SIZE > - parsed_size - BSD_SYMDEF_COUNT_SIZE) + parsed_size -= BSD_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE; + amt = H_GET_32 (abfd, raw_armap); + if (amt > parsed_size + || amt % BSD_SYMDEF_SIZE != 0) { /* Probably we're using the wrong byte ordering. */ bfd_set_error (bfd_error_wrong_format); - goto byebye; + goto release_armap; } - ardata->cache = 0; rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE; - stringbase = ((char *) rbase - + ardata->symdef_count * BSD_SYMDEF_SIZE - + BSD_STRING_COUNT_SIZE); - amt = ardata->symdef_count * sizeof (carsym); + stringbase = (char *) rbase + amt + BSD_STRING_COUNT_SIZE; + string_size = parsed_size - amt; + + ardata->symdef_count = amt / BSD_SYMDEF_SIZE; + if (_bfd_mul_overflow (ardata->symdef_count, sizeof (carsym), &amt)) + { + bfd_set_error (bfd_error_no_memory); + goto release_armap; + } ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt); if (!ardata->symdefs) - return FALSE; + goto release_armap; for (counter = 0, set = ardata->symdefs; counter < ardata->symdef_count; counter++, set++, rbase += BSD_SYMDEF_SIZE) { - set->name = H_GET_32 (abfd, rbase) + stringbase; + unsigned nameoff = H_GET_32 (abfd, rbase); + if (nameoff >= string_size) + { + bfd_set_error (bfd_error_malformed_archive); + goto release_armap; + } + set->name = stringbase + nameoff; set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE); } @@ -933,8 +1029,14 @@ do_slurp_bsd_armap (bfd *abfd) /* FIXME, we should provide some way to free raw_ardata when we are done using the strings from it. For now, it seems to be allocated on an objalloc anyway... */ - bfd_has_map (abfd) = TRUE; + abfd->has_armap = TRUE; return TRUE; + + release_armap: + ardata->symdef_count = 0; + ardata->symdefs = NULL; + bfd_release (abfd, raw_armap); + return FALSE; } /* Read a COFF archive symbol table. Returns FALSE on error, TRUE @@ -947,122 +1049,113 @@ do_slurp_coff_armap (bfd *abfd) int *raw_armap, *rawptr; struct artdata *ardata = bfd_ardata (abfd); char *stringbase; + char *stringend; bfd_size_type stringsize; bfd_size_type parsed_size; + ufile_ptr filesize; + size_t nsymz, carsym_size, ptrsize, i; carsym *carsyms; - bfd_size_type nsymz; /* Number of symbols in armap. */ bfd_vma (*swap) (const void *); - char int_buf[sizeof (long)]; - bfd_size_type carsym_size, ptrsize; - unsigned int i; + char int_buf[4]; + struct areltdata *tmp; mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd); if (mapdata == NULL) return FALSE; parsed_size = mapdata->parsed_size; - bfd_release (abfd, mapdata); /* Don't need it any more. */ + free (mapdata); if (bfd_bread (int_buf, 4, abfd) != 4) - { - if (bfd_get_error () != bfd_error_system_call) - bfd_set_error (bfd_error_malformed_archive); - return FALSE; - } + return FALSE; + /* It seems that all numeric information in a coff archive is always - in big endian format, nomatter the host or target. */ + in big endian format, no matter the host or target. */ swap = bfd_getb32; nsymz = bfd_getb32 (int_buf); - stringsize = parsed_size - (4 * nsymz) - 4; - /* ... except that some archive formats are broken, and it may be our - fault - the i960 little endian coff sometimes has big and sometimes - little, because our tools changed. Here's a horrible hack to clean - up the crap. */ + /* The coff armap must be read sequentially. So we construct a + bsd-style one in core all at once, for simplicity. */ - if (stringsize > 0xfffff - && bfd_get_arch (abfd) == bfd_arch_i960 - && bfd_get_flavour (abfd) == bfd_target_coff_flavour) + if (_bfd_mul_overflow (nsymz, sizeof (carsym), &carsym_size)) { - /* This looks dangerous, let's do it the other way around. */ - nsymz = bfd_getl32 (int_buf); - stringsize = parsed_size - (4 * nsymz) - 4; - swap = bfd_getl32; + bfd_set_error (bfd_error_no_memory); + return FALSE; } - /* The coff armap must be read sequentially. So we construct a - bsd-style one in core all at once, for simplicity. */ - - if (nsymz > ~ (bfd_size_type) 0 / sizeof (carsym)) - return FALSE; + filesize = bfd_get_file_size (abfd); + ptrsize = 4 * nsymz; + if ((filesize != 0 && parsed_size > filesize) + || parsed_size < 4 + || parsed_size - 4 < ptrsize) + { + bfd_set_error (bfd_error_malformed_archive); + return FALSE; + } - carsym_size = (nsymz * sizeof (carsym)); - ptrsize = (4 * nsymz); + stringsize = parsed_size - ptrsize - 4; if (carsym_size + stringsize + 1 <= carsym_size) + { + bfd_set_error (bfd_error_no_memory); + return FALSE; + } + + /* Allocate and read in the raw offsets. */ + raw_armap = (int *) _bfd_malloc_and_read (abfd, ptrsize, ptrsize); + if (raw_armap == NULL) return FALSE; - ardata->symdefs = (struct carsym *) bfd_zalloc (abfd, - carsym_size + stringsize + 1); + ardata->symdefs = (struct carsym *) bfd_alloc (abfd, + carsym_size + stringsize + 1); if (ardata->symdefs == NULL) - return FALSE; + goto free_armap; carsyms = ardata->symdefs; stringbase = ((char *) ardata->symdefs) + carsym_size; - /* Allocate and read in the raw offsets. */ - raw_armap = (int *) bfd_alloc (abfd, ptrsize); - if (raw_armap == NULL) + if (bfd_bread (stringbase, stringsize, abfd) != stringsize) goto release_symdefs; - if (bfd_bread (raw_armap, ptrsize, abfd) != ptrsize - || (bfd_bread (stringbase, stringsize, abfd) != stringsize)) - { - if (bfd_get_error () != bfd_error_system_call) - bfd_set_error (bfd_error_malformed_archive); - goto release_raw_armap; - } /* OK, build the carsyms. */ + stringend = stringbase + stringsize; + *stringend = 0; for (i = 0; i < nsymz; i++) { rawptr = raw_armap + i; carsyms->file_offset = swap ((bfd_byte *) rawptr); carsyms->name = stringbase; - stringbase += strlen (stringbase) + 1; + stringbase += strlen (stringbase); + if (stringbase != stringend) + ++stringbase; carsyms++; } - *stringbase = 0; ardata->symdef_count = nsymz; ardata->first_file_filepos = bfd_tell (abfd); /* Pad to an even boundary if you have to. */ ardata->first_file_filepos += (ardata->first_file_filepos) % 2; + if (bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET) != 0) + goto release_symdefs; - bfd_has_map (abfd) = TRUE; - bfd_release (abfd, raw_armap); + abfd->has_armap = TRUE; + free (raw_armap); /* Check for a second archive header (as used by PE). */ - { - struct areltdata *tmp; - - bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET); - tmp = (struct areltdata *) _bfd_read_ar_hdr (abfd); - if (tmp != NULL) - { - if (tmp->arch_header[0] == '/' - && tmp->arch_header[1] == ' ') - { - ardata->first_file_filepos += - (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1; - } - bfd_release (abfd, tmp); - } - } + tmp = (struct areltdata *) _bfd_read_ar_hdr (abfd); + if (tmp != NULL) + { + if (tmp->arch_header[0] == '/' + && tmp->arch_header[1] == ' ') + ardata->first_file_filepos + += (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1; + free (tmp); + } return TRUE; -release_raw_armap: - bfd_release (abfd, raw_armap); -release_symdefs: + release_symdefs: bfd_release (abfd, (ardata)->symdefs); + free_armap: + free (raw_armap); return FALSE; } @@ -1090,10 +1183,9 @@ bfd_slurp_armap (bfd *abfd) return do_slurp_coff_armap (abfd); else if (CONST_STRNEQ (nextname, "/SYM64/ ")) { - /* 64bit ELF (Irix 6) archive. */ + /* 64bit (Irix 6) archive. */ #ifdef BFD64 - extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *); - return bfd_elf64_archive_slurp_armap (abfd); + return _bfd_archive_64_bit_slurp_armap (abfd); #else bfd_set_error (bfd_error_wrong_format); return FALSE; @@ -1114,119 +1206,13 @@ bfd_slurp_armap (bfd *abfd) return FALSE; if (bfd_seek (abfd, -(file_ptr) (sizeof (hdr) + 20), SEEK_CUR) != 0) return FALSE; + extname[20] = 0; if (CONST_STRNEQ (extname, "__.SYMDEF SORTED") || CONST_STRNEQ (extname, "__.SYMDEF")) return do_slurp_bsd_armap (abfd); } - bfd_has_map (abfd) = FALSE; - return TRUE; -} - -/* Returns FALSE on error, TRUE otherwise. */ -/* Flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the - header is in a slightly different order and the map name is '/'. - This flavour is used by hp300hpux. */ - -#define HPUX_SYMDEF_COUNT_SIZE 2 - -bfd_boolean -bfd_slurp_bsd_armap_f2 (bfd *abfd) -{ - struct areltdata *mapdata; - char nextname[17]; - unsigned int counter; - bfd_byte *raw_armap, *rbase; - struct artdata *ardata = bfd_ardata (abfd); - char *stringbase; - unsigned int stringsize; - unsigned int left; - bfd_size_type amt; - carsym *set; - int i = bfd_bread (nextname, 16, abfd); - - if (i == 0) - return TRUE; - if (i != 16) - return FALSE; - - /* The archive has at least 16 bytes in it. */ - if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0) - return FALSE; - - if (CONST_STRNEQ (nextname, "__.SYMDEF ") - || CONST_STRNEQ (nextname, "__.SYMDEF/ ")) /* Old Linux archives. */ - return do_slurp_bsd_armap (abfd); - - if (! CONST_STRNEQ (nextname, "/ ")) - { - bfd_has_map (abfd) = FALSE; - return TRUE; - } - - mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd); - if (mapdata == NULL) - return FALSE; - - if (mapdata->parsed_size < HPUX_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE) - { - wrong_format: - bfd_set_error (bfd_error_wrong_format); - byebye: - bfd_release (abfd, mapdata); - return FALSE; - } - left = mapdata->parsed_size - HPUX_SYMDEF_COUNT_SIZE - BSD_STRING_COUNT_SIZE; - - amt = mapdata->parsed_size; - raw_armap = (bfd_byte *) bfd_zalloc (abfd, amt); - if (raw_armap == NULL) - goto byebye; - - if (bfd_bread (raw_armap, amt, abfd) != amt) - { - if (bfd_get_error () != bfd_error_system_call) - bfd_set_error (bfd_error_malformed_archive); - goto byebye; - } - - ardata->symdef_count = H_GET_16 (abfd, raw_armap); - - ardata->cache = 0; - - stringsize = H_GET_32 (abfd, raw_armap + HPUX_SYMDEF_COUNT_SIZE); - if (stringsize > left) - goto wrong_format; - left -= stringsize; - - /* Skip sym count and string sz. */ - stringbase = ((char *) raw_armap - + HPUX_SYMDEF_COUNT_SIZE - + BSD_STRING_COUNT_SIZE); - rbase = (bfd_byte *) stringbase + stringsize; - amt = ardata->symdef_count * BSD_SYMDEF_SIZE; - if (amt > left) - goto wrong_format; - - ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt); - if (!ardata->symdefs) - return FALSE; - - for (counter = 0, set = ardata->symdefs; - counter < ardata->symdef_count; - counter++, set++, rbase += BSD_SYMDEF_SIZE) - { - set->name = H_GET_32 (abfd, rbase) + stringbase; - set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE); - } - - ardata->first_file_filepos = bfd_tell (abfd); - /* Pad to an even boundary if you have to. */ - ardata->first_file_filepos += (ardata->first_file_filepos) % 2; - /* FIXME, we should provide some way to free raw_ardata when - we are done using the strings from it. For now, it seems - to be allocated on an objalloc anyway... */ - bfd_has_map (abfd) = TRUE; + abfd->has_armap = FALSE; return TRUE; } @@ -1246,8 +1232,6 @@ bfd_boolean _bfd_slurp_extended_name_table (bfd *abfd) { char nextname[17]; - struct areltdata *namedata; - bfd_size_type amt; /* FIXME: Formatting sucks here, and in case of failure of BFD_READ, we probably don't want to return TRUE. */ @@ -1256,6 +1240,10 @@ _bfd_slurp_extended_name_table (bfd *abfd) if (bfd_bread (nextname, 16, abfd) == 16) { + struct areltdata *namedata; + bfd_size_type amt; + ufile_ptr filesize; + if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0) return FALSE; @@ -1271,16 +1259,22 @@ _bfd_slurp_extended_name_table (bfd *abfd) if (namedata == NULL) return FALSE; + filesize = bfd_get_file_size (abfd); amt = namedata->parsed_size; - if (amt + 1 == 0) - goto byebye; + if (amt + 1 == 0 || (filesize != 0 && amt > filesize)) + { + bfd_set_error (bfd_error_malformed_archive); + goto byebye; + } bfd_ardata (abfd)->extended_names_size = amt; - bfd_ardata (abfd)->extended_names = (char *) bfd_zalloc (abfd, amt + 1); + bfd_ardata (abfd)->extended_names = (char *) bfd_alloc (abfd, amt + 1); if (bfd_ardata (abfd)->extended_names == NULL) { byebye: - bfd_release (abfd, namedata); + free (namedata); + bfd_ardata (abfd)->extended_names = NULL; + bfd_ardata (abfd)->extended_names_size = 0; return FALSE; } @@ -1292,16 +1286,18 @@ _bfd_slurp_extended_name_table (bfd *abfd) bfd_ardata (abfd)->extended_names = NULL; goto byebye; } + bfd_ardata (abfd)->extended_names[amt] = 0; /* Since the archive is supposed to be printable if it contains text, the entries in the list are newline-padded, not null padded. In SVR4-style archives, the names also have a trailing '/'. DOS/NT created archive often have \ in them - We'll fix all problems here.. */ + We'll fix all problems here. */ { char *ext_names = bfd_ardata (abfd)->extended_names; char *temp = ext_names; char *limit = temp + namedata->parsed_size; + for (; temp < limit; ++temp) { if (*temp == ARFMAG[1]) @@ -1317,8 +1313,7 @@ _bfd_slurp_extended_name_table (bfd *abfd) bfd_ardata (abfd)->first_file_filepos += (bfd_ardata (abfd)->first_file_filepos) % 2; - /* FIXME, we can't release namedata here because it was allocated - below extended_names on the objalloc... */ + free (namedata); } return TRUE; } @@ -1335,6 +1330,9 @@ normalize (bfd *abfd, const char *file) const char *last; char *copy; + if (abfd->flags & BFD_ARCHIVE_FULL_PATH) + return file; + first = file + strlen (file) - 1; last = first + 1; @@ -1362,8 +1360,10 @@ normalize (bfd *abfd, const char *file) #else static const char * -normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file) +normalize (bfd *abfd, const char *file) { + if (abfd->flags & BFD_ARCHIVE_FULL_PATH) + return file; return lbasename (file); } #endif @@ -1373,16 +1373,16 @@ normalize (bfd *abfd ATTRIBUTE_UNUSED, const char *file) Relative path Reference path Result ------------- -------------- ------ - bar.o lib.a bar.o - foo/bar.o lib.a foo/bar.o - bar.o foo/lib.a ../bar.o - foo/bar.o baz/lib.a ../foo/bar.o - bar.o ../lib.a /bar.o - ; ../bar.o ../lib.a bar.o - ; ../bar.o lib.a ../bar.o - foo/bar.o ../lib.a /foo/bar.o - bar.o ../../lib.a //bar.o - bar.o foo/baz/lib.a ../../bar.o + bar.o lib.a bar.o + foo/bar.o lib.a foo/bar.o + bar.o foo/lib.a ../bar.o + foo/bar.o baz/lib.a ../foo/bar.o + bar.o ../lib.a /bar.o + ; ../bar.o ../lib.a bar.o + ; ../bar.o lib.a ../bar.o + foo/bar.o ../lib.a /foo/bar.o + bar.o ../../lib.a //bar.o + bar.o foo/baz/lib.a ../../bar.o Note - the semicolons above are there to prevent the BFD chew utility from interpreting those lines as prototypes to put into @@ -1521,6 +1521,15 @@ _bfd_archive_coff_construct_extended_name_table (bfd *abfd, return _bfd_construct_extended_name_table (abfd, TRUE, tabloc, tablen); } +bfd_boolean +_bfd_noarchive_construct_extended_name_table (bfd *abfd ATTRIBUTE_UNUSED, + char **tabloc ATTRIBUTE_UNUSED, + bfd_size_type *len ATTRIBUTE_UNUSED, + const char **name ATTRIBUTE_UNUSED) +{ + return TRUE; +} + /* Follows archive_head and produces an extended name table if necessary. Returns (in tabloc) a pointer to an extended name table, and in tablen the length of the table. If it makes an entry @@ -1589,7 +1598,7 @@ _bfd_construct_extended_name_table (bfd *abfd, continue; } - normal = normalize (current, current->filename); + normal = normalize (abfd, current->filename); if (normal == NULL) return FALSE; @@ -1629,7 +1638,7 @@ _bfd_construct_extended_name_table (bfd *abfd, if (total_namelen == 0) return TRUE; - *tabloc = (char *) bfd_zalloc (abfd, total_namelen); + *tabloc = (char *) bfd_alloc (abfd, total_namelen); if (*tabloc == NULL) return FALSE; @@ -1670,7 +1679,7 @@ _bfd_construct_extended_name_table (bfd *abfd, } else { - normal = normalize (current, filename); + normal = normalize (abfd, filename); if (normal == NULL) return FALSE; } @@ -1686,16 +1695,14 @@ _bfd_construct_extended_name_table (bfd *abfd, stroff = last_stroff; else { - strcpy (strptr, normal); - if (! trailing_slash) - strptr[thislen] = ARFMAG[1]; - else - { - strptr[thislen] = '/'; - strptr[thislen + 1] = ARFMAG[1]; - } + last_filename = filename; stroff = strptr - *tabloc; last_stroff = stroff; + memcpy (strptr, normal, thislen); + strptr += thislen; + if (trailing_slash) + *strptr++ = '/'; + *strptr++ = ARFMAG[1]; } hdr->ar_name[0] = ar_padchar (current); if (bfd_is_thin_archive (abfd) && current->origin > 0) @@ -1708,13 +1715,6 @@ _bfd_construct_extended_name_table (bfd *abfd, } else _bfd_ar_spacepad (hdr->ar_name + 1, maxname - 1, "%-ld", stroff); - if (normal != last_filename) - { - strptr += thislen + 1; - if (trailing_slash) - ++strptr; - last_filename = filename; - } } } @@ -1741,7 +1741,7 @@ _bfd_archive_bsd44_construct_extended_name_table (bfd *abfd, current != NULL; current = current->archive_next) { - const char *normal = normalize (current, current->filename); + const char *normal = normalize (abfd, current->filename); int has_space = 0; unsigned int len; @@ -1819,6 +1819,12 @@ _bfd_bsd44_write_ar_hdr (bfd *archive, bfd *abfd) } return TRUE; } + +bfd_boolean +_bfd_noarchive_write_ar_hdr (bfd *archive, bfd *abfd ATTRIBUTE_UNUSED) +{ + return _bfd_bool_bfd_false_error (archive); +} /* A couple of functions for creating ar_hdrs. */ @@ -1857,7 +1863,7 @@ bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member) struct stat status; struct areltdata *ared; struct ar_hdr *hdr; - bfd_size_type amt; + size_t amt; if (member && (member->flags & BFD_IN_MEMORY) != 0) { @@ -1886,7 +1892,7 @@ bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member) } amt = sizeof (struct ar_hdr) + sizeof (struct areltdata); - ared = (struct areltdata *) bfd_zalloc (abfd, amt); + ared = (struct areltdata *) bfd_zmalloc (amt); if (ared == NULL) return NULL; hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata)); @@ -1916,6 +1922,12 @@ bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member) status.st_gid); _bfd_ar_spacepad (hdr->ar_mode, sizeof (hdr->ar_mode), "%-8lo", status.st_mode); + if (status.st_size - (bfd_size_type) status.st_size != 0) + { + bfd_set_error (bfd_error_file_too_big); + free (ared); + return NULL; + } if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size), status.st_size)) { free (ared); @@ -1943,10 +1955,12 @@ bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf) } hdr = arch_hdr (abfd); - + /* PR 17512: file: 3d9e9fe9. */ + if (hdr == NULL) + return -1; #define foo(arelt, stelt, size) \ buf->stelt = strtol (hdr->arelt, &aloser, size); \ - if (aloser == hdr->arelt) \ + if (aloser == hdr->arelt) \ return -1; /* Some platforms support special notations for large IDs. */ @@ -2081,6 +2095,13 @@ bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr) if (length < 16) (hdr->ar_name)[length] = ar_padchar (abfd); } + +void +_bfd_noarchive_truncate_arname (bfd *abfd ATTRIBUTE_UNUSED, + const char *pathname ATTRIBUTE_UNUSED, + char *arhdr ATTRIBUTE_UNUSED) +{ +} /* The BFD is open for write and has its format set to bfd_archive. */ @@ -2192,17 +2213,13 @@ _bfd_write_archive_contents (bfd *arch) while (remaining) { - unsigned int amt = DEFAULT_BUFFERSIZE; + size_t amt = DEFAULT_BUFFERSIZE; if (amt > remaining) amt = remaining; errno = 0; if (bfd_bread (buffer, amt, current) != amt) - { - if (bfd_get_error () != bfd_error_system_call) - bfd_set_error (bfd_error_file_truncated); - goto input_err; - } + goto input_err; if (bfd_bwrite (buffer, amt, arch) != amt) return FALSE; remaining -= amt; @@ -2228,8 +2245,8 @@ _bfd_write_archive_contents (bfd *arch) { if (bfd_update_armap_timestamp (arch)) break; - (*_bfd_error_handler) - (_("Warning: writing archive was slow: rewriting timestamp\n")); + _bfd_error_handler + (_("warning: writing archive was slow: rewriting timestamp")); } while (++tries < 6); } @@ -2237,7 +2254,7 @@ _bfd_write_archive_contents (bfd *arch) return TRUE; input_err: - bfd_set_error (bfd_error_on_input, current, bfd_get_error ()); + bfd_set_input_error (current, bfd_get_error ()); return FALSE; } @@ -2256,7 +2273,8 @@ _bfd_compute_and_write_armap (bfd *arch, unsigned int elength) asymbol **syms = NULL; long syms_max = 0; bfd_boolean ret; - bfd_size_type amt; + size_t amt; + static bfd_boolean report_plugin_err = TRUE; /* Dunno if this is the best place for this info... */ if (elength != 0) @@ -2291,6 +2309,14 @@ _bfd_compute_and_write_armap (bfd *arch, unsigned int elength) long symcount; long src_count; + if (current->lto_slim_object && report_plugin_err) + { + report_plugin_err = FALSE; + _bfd_error_handler + (_("%pB: plugin needed to handle lto object"), + current); + } + storage = bfd_get_symtab_upper_bound (current); if (storage < 0) goto error_return; @@ -2339,6 +2365,18 @@ _bfd_compute_and_write_armap (bfd *arch, unsigned int elength) map = new_map; } + if (syms[src_count]->name[0] == '_' + && syms[src_count]->name[1] == '_' + && strcmp (syms[src_count]->name + + (syms[src_count]->name[2] == '_'), + "__gnu_lto_slim") == 0 + && report_plugin_err) + { + report_plugin_err = FALSE; + _bfd_error_handler + (_("%pB: plugin needed to handle lto object"), + current); + } namelen = strlen (syms[src_count]->name); amt = sizeof (char *); map[orl_count].name = (char **) bfd_alloc (arch, amt); @@ -2390,29 +2428,60 @@ _bfd_compute_and_write_armap (bfd *arch, unsigned int elength) } bfd_boolean -bsd_write_armap (bfd *arch, - unsigned int elength, - struct orl *map, - unsigned int orl_count, - int stridx) +_bfd_bsd_write_armap (bfd *arch, + unsigned int elength, + struct orl *map, + unsigned int orl_count, + int stridx) { int padit = stridx & 1; unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE; unsigned int stringsize = stridx + padit; /* Include 8 bytes to store ranlibsize and stringsize in output. */ unsigned int mapsize = ranlibsize + stringsize + 8; - file_ptr firstreal; - bfd *current = arch->archive_head; - bfd *last_elt = current; /* Last element arch seen. */ + file_ptr firstreal, first; + bfd *current; + bfd *last_elt; bfd_byte temp[4]; unsigned int count; struct ar_hdr hdr; long uid, gid; - file_ptr max_first_real = 1; - max_first_real <<= 31; + first = mapsize + elength + sizeof (struct ar_hdr) + SARMAG; - firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG; +#ifdef BFD64 + firstreal = first; + current = arch->archive_head; + last_elt = current; /* Last element arch seen. */ + for (count = 0; count < orl_count; count++) + { + unsigned int offset; + + if (map[count].u.abfd != last_elt) + { + do + { + struct areltdata *ared = arch_eltdata (current); + + firstreal += (ared->parsed_size + ared->extra_size + + sizeof (struct ar_hdr)); + firstreal += firstreal % 2; + current = current->archive_next; + } + while (current != map[count].u.abfd); + } + + /* The archive file format only has 4 bytes to store the offset + of the member. Generate 64-bit archive if an archive is past + its 4Gb limit. */ + offset = (unsigned int) firstreal; + if (firstreal != (file_ptr) offset) + return _bfd_archive_64_bit_write_armap (arch, elength, map, + orl_count, stridx); + + last_elt = current; + } +#endif /* If deterministic, we use 0 as the timestamp in the map. Some linkers may require that the archive filesystem modification @@ -2451,8 +2520,12 @@ bsd_write_armap (bfd *arch, if (bfd_bwrite (temp, sizeof (temp), arch) != sizeof (temp)) return FALSE; + firstreal = first; + current = arch->archive_head; + last_elt = current; /* Last element arch seen. */ for (count = 0; count < orl_count; count++) { + unsigned int offset; bfd_byte buf[BSD_SYMDEF_SIZE]; if (map[count].u.abfd != last_elt) @@ -2472,12 +2545,13 @@ bsd_write_armap (bfd *arch, /* The archive file format only has 4 bytes to store the offset of the member. Check to make sure that firstreal has not grown too big. */ - if (firstreal >= max_first_real) + offset = (unsigned int) firstreal; + if (firstreal != (file_ptr) offset) { bfd_set_error (bfd_error_file_truncated); return FALSE; } - + last_elt = current; H_PUT_32 (arch, map[count].namidx, buf); H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE); @@ -2578,11 +2652,11 @@ _bfd_archive_bsd_update_armap_timestamp (bfd *arch) symbol name n-1 */ bfd_boolean -coff_write_armap (bfd *arch, - unsigned int elength, - struct orl *map, - unsigned int symbol_count, - int stridx) +_bfd_coff_write_armap (bfd *arch, + unsigned int elength, + struct orl *map, + unsigned int symbol_count, + int stridx) { /* The size of the ranlib is the number of exported symbols in the archive * the number of bytes in an int, + an int for the count. */ @@ -2590,6 +2664,7 @@ coff_write_armap (bfd *arch, unsigned int stringsize = stridx; unsigned int mapsize = stringsize + ranlibsize; file_ptr archive_member_file_ptr; + file_ptr first_archive_member_file_ptr; bfd *current = arch->archive_head; unsigned int count; struct ar_hdr hdr; @@ -2599,10 +2674,42 @@ coff_write_armap (bfd *arch, mapsize++; /* Work out where the first object file will go in the archive. */ - archive_member_file_ptr = (mapsize - + elength - + sizeof (struct ar_hdr) - + SARMAG); + first_archive_member_file_ptr = (mapsize + + elength + + sizeof (struct ar_hdr) + + SARMAG); + +#ifdef BFD64 + current = arch->archive_head; + count = 0; + archive_member_file_ptr = first_archive_member_file_ptr; + while (current != NULL && count < symbol_count) + { + /* For each symbol which is used defined in this object, write + out the object file's address in the archive. */ + + while (count < symbol_count && map[count].u.abfd == current) + { + unsigned int offset = (unsigned int) archive_member_file_ptr; + + /* Generate 64-bit archive if an archive is past its 4Gb + limit. */ + if (archive_member_file_ptr != (file_ptr) offset) + return _bfd_archive_64_bit_write_armap (arch, elength, map, + symbol_count, stridx); + count++; + } + archive_member_file_ptr += sizeof (struct ar_hdr); + if (! bfd_is_thin_archive (arch)) + { + /* Add size of this archive entry. */ + archive_member_file_ptr += arelt_size (current); + /* Remember about the even alignment. */ + archive_member_file_ptr += archive_member_file_ptr % 2; + } + current = current->archive_next; + } +#endif memset (&hdr, ' ', sizeof (struct ar_hdr)); hdr.ar_name[0] = '/'; @@ -2633,6 +2740,7 @@ coff_write_armap (bfd *arch, current = arch->archive_head; count = 0; + archive_member_file_ptr = first_archive_member_file_ptr; while (current != NULL && count < symbol_count) { /* For each symbol which is used defined in this object, write @@ -2682,3 +2790,80 @@ coff_write_armap (bfd *arch, return TRUE; } + +bfd_boolean +_bfd_noarchive_write_armap + (bfd *arch ATTRIBUTE_UNUSED, + unsigned int elength ATTRIBUTE_UNUSED, + struct orl *map ATTRIBUTE_UNUSED, + unsigned int orl_count ATTRIBUTE_UNUSED, + int stridx ATTRIBUTE_UNUSED) +{ + return TRUE; +} + +static int +archive_close_worker (void **slot, void *inf ATTRIBUTE_UNUSED) +{ + struct ar_cache *ent = (struct ar_cache *) *slot; + + bfd_close_all_done (ent->arbfd); + return 1; +} + +void +_bfd_unlink_from_archive_parent (bfd *abfd) +{ + if (arch_eltdata (abfd) != NULL) + { + struct areltdata *ared = arch_eltdata (abfd); + htab_t htab = (htab_t) ared->parent_cache; + + if (htab) + { + struct ar_cache ent; + void **slot; + + ent.ptr = ared->key; + slot = htab_find_slot (htab, &ent, NO_INSERT); + if (slot != NULL) + { + BFD_ASSERT (((struct ar_cache *) *slot)->arbfd == abfd); + htab_clear_slot (htab, slot); + } + } + } +} + +bfd_boolean +_bfd_archive_close_and_cleanup (bfd *abfd) +{ + if (bfd_read_p (abfd) && abfd->format == bfd_archive) + { + bfd *nbfd; + bfd *next; + htab_t htab; + + /* Close nested archives (if this bfd is a thin archive). */ + for (nbfd = abfd->nested_archives; nbfd; nbfd = next) + { + next = nbfd->archive_next; + bfd_close (nbfd); + } + + htab = bfd_ardata (abfd)->cache; + if (htab) + { + htab_traverse_noresize (htab, archive_close_worker, NULL); + htab_delete (htab); + bfd_ardata (abfd)->cache = NULL; + } + } + + _bfd_unlink_from_archive_parent (abfd); + + if (abfd->is_linker_output) + (*abfd->link.hash->hash_table_free) (abfd); + + return TRUE; +}