X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Fcompress.c;h=728ba39dfbf748c688bb8c9f1a8d28c5a1ae9bd0;hb=7a87e9c80506af4c3f658c1a796c4ad18730e46c;hp=17b24e8ad0260ea3949add934695fbcef3832127;hpb=5150992626e67d2f6d1573737e06126bfb712c30;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/compress.c b/bfd/compress.c index 17b24e8ad0..728ba39dfb 100644 --- a/bfd/compress.c +++ b/bfd/compress.c @@ -1,5 +1,5 @@ /* Compressed section support (intended for debug sections). - Copyright (C) 2008-2015 Free Software Foundation, Inc. + Copyright (C) 2008-2020 Free Software Foundation, Inc. This file is part of BFD, the Binary File Descriptor library. @@ -37,11 +37,14 @@ decompress_contents (bfd_byte *compressed_buffer, /* It is possible the section consists of several compressed buffers concatenated together, so we uncompress in a loop. */ - strm.zalloc = NULL; - strm.zfree = NULL; - strm.opaque = NULL; - strm.avail_in = compressed_size - 12; - strm.next_in = (Bytef*) compressed_buffer + 12; + /* PR 18313: The state field in the z_stream structure is supposed + to be invisible to the user (ie us), but some compilers will + still complain about it being used without initialisation. So + we first zero the entire z_stream structure and then set the fields + that we need. */ + memset (& strm, 0, sizeof strm); + strm.avail_in = compressed_size; + strm.next_in = (Bytef*) compressed_buffer; strm.avail_out = uncompressed_size; BFD_ASSERT (Z_OK == 0); @@ -51,7 +54,7 @@ decompress_contents (bfd_byte *compressed_buffer, if (rc != Z_OK) break; strm.next_out = ((Bytef*) uncompressed_buffer - + (uncompressed_size - strm.avail_out)); + + (uncompressed_size - strm.avail_out)); rc = inflate (&strm, Z_FINISH); if (rc != Z_STREAM_END) break; @@ -64,8 +67,7 @@ decompress_contents (bfd_byte *compressed_buffer, /* Compress data of the size specified in @var{uncompressed_size} and pointed to by @var{uncompressed_buffer} using zlib and store as the contents field. This function assumes the contents - field was allocated using bfd_malloc() or equivalent. If zlib - is not installed on this machine, the input is unmodified. + field was allocated using bfd_malloc() or equivalent. Return the uncompressed size if the full section contents is compressed successfully. Otherwise return 0. */ @@ -79,18 +81,21 @@ bfd_compress_section_contents (bfd *abfd, sec_ptr sec, bfd_byte *buffer; bfd_size_type buffer_size; bfd_boolean decompress; -#if defined(__GNUC__) && GCC_VERSION < 4007 - /* Work around a GCC uninitialized warning bug fixed in GCC 4.7. */ int zlib_size = 0; -#else - int zlib_size; -#endif int orig_compression_header_size; - int compression_header_size - = bfd_get_compression_header_size (abfd, NULL); + bfd_size_type orig_uncompressed_size; + unsigned int orig_uncompressed_alignment_pow; + int header_size = bfd_get_compression_header_size (abfd, NULL); bfd_boolean compressed = bfd_is_section_compressed_with_header (abfd, sec, - &orig_compression_header_size); + &orig_compression_header_size, + &orig_uncompressed_size, + &orig_uncompressed_alignment_pow); + + /* Either ELF compression header or the 12-byte, "ZLIB" + 8-byte size, + overhead in .zdebug* section. */ + if (!header_size) + header_size = 12; if (compressed) { @@ -103,74 +108,75 @@ bfd_compress_section_contents (bfd *abfd, sec_ptr sec, if (orig_compression_header_size == 0) { /* Convert it from .zdebug* section. Get the uncompressed - size first. */ - zlib_size = uncompressed_size; - compressed_size = zlib_size + compression_header_size; - uncompressed_size = bfd_getb64 (uncompressed_buffer + 4); + size first. We need to subtract the 12-byte overhead in + .zdebug* section. Set orig_compression_header_size to + the 12-bye overhead. */ + orig_compression_header_size = 12; + zlib_size = uncompressed_size - 12; } else { - /* Convert it to .zdebug* section. */ + /* Convert it to .zdebug* section. */ zlib_size = uncompressed_size - orig_compression_header_size; - compressed_size = zlib_size; } + + /* Add the header size. */ + compressed_size = zlib_size + header_size; } else - compressed_size = compressBound (uncompressed_size) + 12; + compressed_size = compressBound (uncompressed_size) + header_size; - /* When converting from .zdebug* section, uncompress if it leads to - smaller size. */ - if (compressed - && orig_compression_header_size == 0 - && compressed_size > uncompressed_size) + /* Uncompress if it leads to smaller size. */ + if (compressed && compressed_size > orig_uncompressed_size) { decompress = TRUE; - buffer_size = uncompressed_size; + buffer_size = orig_uncompressed_size; } else { decompress = FALSE; - buffer_size = compressed_size + compression_header_size; + buffer_size = compressed_size; } - buffer = (bfd_byte *) bfd_malloc (buffer_size); + buffer = (bfd_byte *) bfd_alloc (abfd, buffer_size); if (buffer == NULL) return 0; if (compressed) { - sec->size = uncompressed_size; + sec->size = orig_uncompressed_size; if (decompress) { - if (!decompress_contents (uncompressed_buffer, zlib_size, - buffer, uncompressed_size)) + if (!decompress_contents (uncompressed_buffer + + orig_compression_header_size, + zlib_size, buffer, buffer_size)) { bfd_set_error (bfd_error_bad_value); - free (buffer); + bfd_release (abfd, buffer); return 0; } free (uncompressed_buffer); + bfd_set_section_alignment (sec, orig_uncompressed_alignment_pow); + sec->contents = buffer; sec->compress_status = COMPRESS_SECTION_DONE; - return uncompressed_size; + return orig_uncompressed_size; } else { bfd_update_compression_header (abfd, buffer, sec); - memmove (buffer + compression_header_size, + memmove (buffer + header_size, uncompressed_buffer + orig_compression_header_size, zlib_size); } } else { - bfd_size_type size = uncompressed_size; - int header_size = 12 + compression_header_size; if (compress ((Bytef*) buffer + header_size, &compressed_size, (const Bytef*) uncompressed_buffer, uncompressed_size) != Z_OK) { - free (buffer); + bfd_release (abfd, buffer); bfd_set_error (bfd_error_bad_value); return 0; } @@ -179,17 +185,12 @@ bfd_compress_section_contents (bfd *abfd, sec_ptr sec, /* PR binutils/18087: If compression didn't make the section smaller, just keep it uncompressed. */ if (compressed_size < uncompressed_size) - { - bfd_update_compression_header (abfd, buffer, sec); - - /* Write the zlib header. In this case, it should be "ZLIB" - followed by the uncompressed section size, 8 bytes in - big-endian order. */ - memcpy (buffer + compression_header_size, "ZLIB", 4); - bfd_putb64 (size, buffer + compression_header_size + 4); - } + bfd_update_compression_header (abfd, buffer, sec); else { + /* NOTE: There is a small memory leak here since + uncompressed_buffer is malloced and won't be freed. */ + bfd_release (abfd, buffer); sec->contents = uncompressed_buffer; sec->compress_status = COMPRESS_SECTION_NONE; return uncompressed_size; @@ -248,9 +249,40 @@ bfd_get_full_section_contents (bfd *abfd, sec_ptr sec, bfd_byte **ptr) case COMPRESS_SECTION_NONE: if (p == NULL) { + ufile_ptr filesize = bfd_get_file_size (abfd); + if (filesize > 0 + && filesize < sz + /* PR 24753: Linker created sections can be larger than + the file size, eg if they are being used to hold stubs. */ + && (bfd_section_flags (sec) & SEC_LINKER_CREATED) == 0 + /* PR 24753: Sections which have no content should also be + excluded as they contain no size on disk. */ + && (bfd_section_flags (sec) & SEC_HAS_CONTENTS) != 0 + /* The MMO file format supports its own special compression + technique, but it uses COMPRESS_SECTION_NONE when loading + a section's contents. */ + && bfd_get_flavour (abfd) != bfd_target_mmo_flavour) + { + /* PR 24708: Avoid attempts to allocate a ridiculous amount + of memory. */ + bfd_set_error (bfd_error_no_memory); + _bfd_error_handler + /* xgettext:c-format */ + (_("error: %pB(%pA) section size (%#" PRIx64 " bytes) is larger than file size (%#" PRIx64 " bytes)"), + abfd, sec, (uint64_t) sz, (uint64_t) filesize); + return FALSE; + } p = (bfd_byte *) bfd_malloc (sz); if (p == NULL) - return FALSE; + { + /* PR 20801: Provide a more helpful error message. */ + if (bfd_get_error () == bfd_error_no_memory) + _bfd_error_handler + /* xgettext:c-format */ + (_("error: %pB(%pA) is too large (%#" PRIx64 " bytes)"), + abfd, sec, (uint64_t) sz); + return FALSE; + } } if (!bfd_get_section_contents (abfd, sec, p, 0, sz)) @@ -290,8 +322,12 @@ bfd_get_full_section_contents (bfd *abfd, sec_ptr sec, bfd_byte **ptr) goto fail_compressed; compression_header_size = bfd_get_compression_header_size (abfd, sec); + if (compression_header_size == 0) + /* Set header size to the zlib header size if it is a + SHF_COMPRESSED section. */ + compression_header_size = 12; if (!decompress_contents (compressed_buffer + compression_header_size, - sec->compressed_size, p, sz)) + sec->compressed_size - compression_header_size, p, sz)) { bfd_set_error (bfd_error_bad_value); if (p != *ptr) @@ -354,49 +390,63 @@ FUNCTION SYNOPSIS bfd_boolean bfd_is_section_compressed_with_header (bfd *abfd, asection *section, - int *compression_header_size_p); + int *compression_header_size_p, + bfd_size_type *uncompressed_size_p, + unsigned int *uncompressed_alignment_power_p); DESCRIPTION Return @code{TRUE} if @var{section} is compressed. Compression - header size is returned in @var{compression_header_size_p}. If - compression is unsupported, compression header size is returned - with -1. + header size is returned in @var{compression_header_size_p}, + uncompressed size is returned in @var{uncompressed_size_p} + and the uncompressed data alignement power is returned in + @var{uncompressed_align_pow_p}. If compression is + unsupported, compression header size is returned with -1 + and uncompressed size is returned with 0. */ bfd_boolean bfd_is_section_compressed_with_header (bfd *abfd, sec_ptr sec, - int *compression_header_size_p) + int *compression_header_size_p, + bfd_size_type *uncompressed_size_p, + unsigned int *uncompressed_align_pow_p) { - bfd_byte header[MAX_COMPRESSION_HEADER_SIZE + 12]; + bfd_byte header[MAX_COMPRESSION_HEADER_SIZE]; int compression_header_size; - int header_size = 12; + int header_size; unsigned int saved = sec->compress_status; bfd_boolean compressed; + *uncompressed_align_pow_p = 0; + compression_header_size = bfd_get_compression_header_size (abfd, sec); if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE) abort (); - header_size += compression_header_size; + header_size = compression_header_size ? compression_header_size : 12; /* Don't decompress the section. */ sec->compress_status = COMPRESS_SECTION_NONE; - /* Read the zlib header. In this case, it should be "ZLIB" followed - by the uncompressed section size, 8 bytes in big-endian order. */ - compressed = bfd_get_section_contents (abfd, sec, header, 0, - header_size) - && CONST_STRNEQ ((char*) header + compression_header_size, - "ZLIB"); + /* Read the header. */ + if (bfd_get_section_contents (abfd, sec, header, 0, header_size)) + { + if (compression_header_size == 0) + /* In this case, it should be "ZLIB" followed by the uncompressed + section size, 8 bytes in big-endian order. */ + compressed = CONST_STRNEQ ((char*) header , "ZLIB"); + else + compressed = TRUE; + } + else + compressed = FALSE; + *uncompressed_size_p = sec->size; if (compressed) { if (compression_header_size != 0) { - bfd_size_type uncompressed_size - = bfd_getb64 ((bfd_byte *) header - + compression_header_size + 4); if (!bfd_check_compression_header (abfd, header, sec, - uncompressed_size)) + uncompressed_size_p, + uncompressed_align_pow_p)) compression_header_size = -1; } /* Check for the pathalogical case of a debug string section that @@ -404,8 +454,10 @@ bfd_is_section_compressed_with_header (bfd *abfd, sec_ptr sec, no uncompressed .debug_str section would ever be big enough to have the first byte of its (big-endian) size be non-zero. */ else if (strcmp (sec->name, ".debug_str") == 0 - && ISPRINT (header[compression_header_size + 4])) + && ISPRINT (header[4])) compressed = FALSE; + else + *uncompressed_size_p = bfd_getb64 (header + 4); } /* Restore compress_status. */ @@ -430,9 +482,14 @@ bfd_boolean bfd_is_section_compressed (bfd *abfd, sec_ptr sec) { int compression_header_size; + bfd_size_type uncompressed_size; + unsigned int uncompressed_align_power; return (bfd_is_section_compressed_with_header (abfd, sec, - &compression_header_size) - && compression_header_size >= 0); + &compression_header_size, + &uncompressed_size, + &uncompressed_align_power) + && compression_header_size >= 0 + && uncompressed_size > 0); } /* @@ -449,23 +506,24 @@ DESCRIPTION DECOMPRESS_SECTION_SIZED. Return @code{FALSE} if the section is not a valid compressed - section or zlib is not installed on this machine. Otherwise, - return @code{TRUE}. + section. Otherwise, return @code{TRUE}. */ bfd_boolean bfd_init_section_decompress_status (bfd *abfd, sec_ptr sec) { - bfd_byte header[MAX_COMPRESSION_HEADER_SIZE + 12]; + bfd_byte header[MAX_COMPRESSION_HEADER_SIZE]; int compression_header_size; - int header_size = 12; + int header_size; bfd_size_type uncompressed_size; + unsigned int uncompressed_alignment_power = 0; compression_header_size = bfd_get_compression_header_size (abfd, sec); if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE) abort (); - header_size += compression_header_size; + header_size = compression_header_size ? compression_header_size : 12; + /* Read the header. */ if (sec->rawsize != 0 || sec->contents != NULL || sec->compress_status != COMPRESS_SECTION_NONE @@ -475,24 +533,28 @@ bfd_init_section_decompress_status (bfd *abfd, sec_ptr sec) return FALSE; } - /* Read the zlib header. In this case, it should be "ZLIB" followed - by the uncompressed section size, 8 bytes in big-endian order. */ - if (! CONST_STRNEQ ((char*) header + compression_header_size, "ZLIB")) + if (compression_header_size == 0) { - bfd_set_error (bfd_error_wrong_format); - return FALSE; + /* In this case, it should be "ZLIB" followed by the uncompressed + section size, 8 bytes in big-endian order. */ + if (! CONST_STRNEQ ((char*) header, "ZLIB")) + { + bfd_set_error (bfd_error_wrong_format); + return FALSE; + } + uncompressed_size = bfd_getb64 (header + 4); } - - uncompressed_size = bfd_getb64 (header + compression_header_size + 4); - if (compression_header_size != 0 - && !bfd_check_compression_header (abfd, header, sec, - uncompressed_size)) + else if (!bfd_check_compression_header (abfd, header, sec, + &uncompressed_size, + &uncompressed_alignment_power)) { bfd_set_error (bfd_error_wrong_format); return FALSE; } + sec->compressed_size = sec->size; sec->size = uncompressed_size; + bfd_set_section_alignment (sec, uncompressed_alignment_power); sec->compress_status = DECOMPRESS_SECTION_SIZED; return TRUE; @@ -511,8 +573,7 @@ DESCRIPTION compressed size and set compress_status to COMPRESS_SECTION_DONE. Return @code{FALSE} if the section is not a valid compressed - section or zlib is not installed on this machine. Otherwise, - return @code{TRUE}. + section. Otherwise, return @code{TRUE}. */ bfd_boolean @@ -520,7 +581,6 @@ bfd_init_section_compress_status (bfd *abfd, sec_ptr sec) { bfd_size_type uncompressed_size; bfd_byte *uncompressed_buffer; - bfd_boolean ret; /* Error if not opened for read. */ if (abfd->direction != read_direction @@ -536,16 +596,54 @@ bfd_init_section_compress_status (bfd *abfd, sec_ptr sec) /* Read in the full section contents and compress it. */ uncompressed_size = sec->size; uncompressed_buffer = (bfd_byte *) bfd_malloc (uncompressed_size); + /* PR 21431 */ + if (uncompressed_buffer == NULL) + return FALSE; + if (!bfd_get_section_contents (abfd, sec, uncompressed_buffer, 0, uncompressed_size)) - ret = FALSE; - else + return FALSE; + + uncompressed_size = bfd_compress_section_contents (abfd, sec, + uncompressed_buffer, + uncompressed_size); + return uncompressed_size != 0; +} + +/* +FUNCTION + bfd_compress_section + +SYNOPSIS + bfd_boolean bfd_compress_section + (bfd *abfd, asection *section, bfd_byte *uncompressed_buffer); + +DESCRIPTION + If open for write, compress section, update section size with + compressed size and set compress_status to COMPRESS_SECTION_DONE. + + Return @code{FALSE} if compression fail. Otherwise, return + @code{TRUE}. +*/ + +bfd_boolean +bfd_compress_section (bfd *abfd, sec_ptr sec, bfd_byte *uncompressed_buffer) +{ + bfd_size_type uncompressed_size = sec->size; + + /* Error if not opened for write. */ + if (abfd->direction != write_direction + || uncompressed_size == 0 + || uncompressed_buffer == NULL + || sec->contents != NULL + || sec->compressed_size != 0 + || sec->compress_status != COMPRESS_SECTION_NONE) { - uncompressed_size = bfd_compress_section_contents (abfd, sec, - uncompressed_buffer, - uncompressed_size); - ret = uncompressed_size != 0; + bfd_set_error (bfd_error_invalid_operation); + return FALSE; } - return ret; + /* Compress it. */ + return bfd_compress_section_contents (abfd, sec, uncompressed_buffer, + uncompressed_size) != 0; }