X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Farchive.c;h=0c009f10de876b8374141d84b6540252b1f93e3c;hb=8b5d0a4f6ff67aa81275c705508e3f49accc8120;hp=a51c1357e9dd58637b69b328e1399403edbae0ee;hpb=eac61af65bcd24a48633da375527eb3f36ab47ed;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/archive.c b/bfd/archive.c index a51c1357e9..0c009f10de 100644 --- a/bfd/archive.c +++ b/bfd/archive.c @@ -1,5 +1,5 @@ /* BFD back-end for archive files (libraries). - Copyright (C) 1990-2018 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. @@ -212,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) @@ -692,6 +692,13 @@ _bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos) return NULL; } 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; } @@ -721,7 +728,9 @@ _bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos) else { n_bfd->origin = n_bfd->proxy_origin; - n_bfd->filename = xstrdup (filename); + n_bfd->filename = bfd_strdup (filename); + if (n_bfd->filename == NULL) + goto out; } n_bfd->arelt_data = new_areldata; @@ -734,11 +743,14 @@ _bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos) /* Copy is_linker_input. */ n_bfd->is_linker_input = archive->is_linker_input; - if (_bfd_add_bfd_to_archive_cache (archive, filepos, n_bfd)) + if (archive->no_element_cache + || _bfd_add_bfd_to_archive_cache (archive, filepos, n_bfd)) return n_bfd; + out: free (new_areldata); n_bfd->arelt_data = NULL; + bfd_close (n_bfd); return NULL; } @@ -830,12 +842,12 @@ _bfd_noarchive_openr_next_archived_file (bfd *archive, return (bfd *) _bfd_ptr_bfd_null_error (archive); } -const bfd_target * +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) { @@ -844,7 +856,7 @@ 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 && ! bfd_is_thin_archive (abfd)) @@ -885,6 +897,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 @@ -897,18 +910,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); - /* And we ought to close `first' here too. */ + bfd_close (first); } } - return abfd->xvec; + return _bfd_no_cleanup; } /* Some constants for a 32 bit BSD archive structure. We do not @@ -935,11 +951,12 @@ 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); @@ -949,46 +966,51 @@ do_slurp_bsd_armap (bfd *abfd) free (mapdata); /* PR 17512: file: 883ff754. */ /* PR 17512: file: 0458885f. */ - if (parsed_size < 4) - return FALSE; - - 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) + 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; - if (ardata->symdef_count * BSD_SYMDEF_SIZE > - parsed_size - BSD_SYMDEF_COUNT_SIZE) + raw_armap = (bfd_byte *) _bfd_alloc_and_read (abfd, parsed_size, parsed_size); + if (raw_armap == NULL) + return FALSE; + + 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); } @@ -998,8 +1020,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 @@ -1012,14 +1040,15 @@ 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) @@ -1028,98 +1057,96 @@ do_slurp_coff_armap (bfd *abfd) 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; /* 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; + if (_bfd_mul_overflow (nsymz, sizeof (carsym), &carsym_size)) + { + bfd_set_error (bfd_error_no_memory); + return FALSE; + } - carsym_size = (nsymz * sizeof (carsym)); - ptrsize = (4 * nsymz); + 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; + } + + 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. */ - for (i = 0; i < nsymz && stringsize > 0; i++) + stringend = stringbase + stringsize; + *stringend = 0; + for (i = 0; i < nsymz; i++) { - bfd_size_type len; - rawptr = raw_armap + i; carsyms->file_offset = swap ((bfd_byte *) rawptr); carsyms->name = stringbase; - /* PR 17512: file: 4a1d50c1. */ - len = strnlen (stringbase, stringsize); - if (len < stringsize) - len ++; - stringbase += len; - stringsize -= len; + 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; - } - free (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; } @@ -1176,7 +1203,7 @@ bfd_slurp_armap (bfd *abfd) return do_slurp_bsd_armap (abfd); } - bfd_has_map (abfd) = FALSE; + abfd->has_armap = FALSE; return TRUE; } @@ -1196,8 +1223,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. */ @@ -1206,6 +1231,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; @@ -1221,12 +1250,16 @@ _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: @@ -1244,6 +1277,7 @@ _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 @@ -1287,6 +1321,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; @@ -1314,8 +1351,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 @@ -1550,7 +1589,7 @@ _bfd_construct_extended_name_table (bfd *abfd, continue; } - normal = normalize (current, current->filename); + normal = normalize (abfd, current->filename); if (normal == NULL) return FALSE; @@ -1590,7 +1629,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; @@ -1631,7 +1670,7 @@ _bfd_construct_extended_name_table (bfd *abfd, } else { - normal = normalize (current, filename); + normal = normalize (abfd, filename); if (normal == NULL) return FALSE; } @@ -1647,16 +1686,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) @@ -1669,13 +1706,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; - } } } @@ -1702,7 +1732,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; @@ -1824,7 +1854,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) { @@ -2174,17 +2204,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; @@ -2238,7 +2264,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) @@ -2273,6 +2300,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; @@ -2325,10 +2360,14 @@ _bfd_compute_and_write_armap (bfd *arch, unsigned int elength) && syms[src_count]->name[1] == '_' && strcmp (syms[src_count]->name + (syms[src_count]->name[2] == '_'), - "__gnu_lto_slim") == 0) - _bfd_error_handler - (_("%pB: plugin needed to handle lto object"), - current); + "__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);