X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Fcompress.c;h=171de77f38e2e8d4dcac22c3e39d5a8440f23e11;hb=4a114e3e0c1c3337981179b774f1d6d1b06d201f;hp=fe1b0fd3b33f995a51e76037145c3b58f547543d;hpb=e58bcb8f099ec42b3c905480629d1a49dd38b03f;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/compress.c b/bfd/compress.c index fe1b0fd3b3..171de77f38 100644 --- a/bfd/compress.c +++ b/bfd/compress.c @@ -27,49 +27,309 @@ #include #endif +#ifdef HAVE_ZLIB_H +static bfd_boolean +decompress_contents (bfd_byte *compressed_buffer, + bfd_size_type compressed_size, + bfd_byte *uncompressed_buffer, + bfd_size_type uncompressed_size) +{ + z_stream strm; + int rc; + + /* 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; + strm.avail_out = uncompressed_size; + + rc = inflateInit (&strm); + while (strm.avail_in > 0) + { + if (rc != Z_OK) + return FALSE; + strm.next_out = ((Bytef*) uncompressed_buffer + + (uncompressed_size - strm.avail_out)); + rc = inflate (&strm, Z_FINISH); + if (rc != Z_STREAM_END) + return FALSE; + rc = inflateReset (&strm); + } + rc = inflateEnd (&strm); + return rc != Z_OK || strm.avail_out != 0 ? FALSE: TRUE; +} +#endif + /* FUNCTION - bfd_uncompress_section_contents + bfd_compress_section_contents SYNOPSIS - bfd_boolean bfd_uncompress_section_contents - (bfd_byte **buffer, bfd_size_type *size); + bfd_boolean bfd_compress_section_contents + (bfd *abfd, asection *section, bfd_byte *uncompressed_buffer, + bfd_size_type uncompressed_size); DESCRIPTION - Uncompresses a section that was compressed using zlib, in place. At - the call to this function, *@var{buffer} and *@var{size} should point - to the section contents to be uncompressed. At the end of the - function, *@var{buffer} and *@var{size} will point to the uncompressed - contents. This function assumes *BUFFER was allocated using - bfd_malloc() or equivalent. If the section is not a valid compressed - section, or zlib is not installed on this machine, the input is - unmodified. - - Returns @code{FALSE} if unable to uncompress successfully; in that case - the input is unmodified. Otherwise, returns @code{TRUE}. + 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. + + Return @code{TRUE} if the full section contents is compressed + successfully. */ bfd_boolean -bfd_uncompress_section_contents (bfd_byte **buffer ATTRIBUTE_UNUSED, - bfd_size_type *size ATTRIBUTE_UNUSED) +bfd_compress_section_contents (bfd *abfd ATTRIBUTE_UNUSED, + sec_ptr sec ATTRIBUTE_UNUSED, + bfd_byte *uncompressed_buffer ATTRIBUTE_UNUSED, + bfd_size_type uncompressed_size ATTRIBUTE_UNUSED) { #ifndef HAVE_ZLIB_H + bfd_set_error (bfd_error_invalid_operation); return FALSE; #else - bfd_size_type compressed_size = *size; - bfd_byte *compressed_buffer = *buffer; + bfd_size_type compressed_size; + bfd_byte *compressed_buffer; + + compressed_size = compressBound (uncompressed_size) + 12; + compressed_buffer = (bfd_byte *) bfd_malloc (compressed_size); + + if (compress ((Bytef*) compressed_buffer + 12, + &compressed_size, + (const Bytef*) uncompressed_buffer, + uncompressed_size) != Z_OK) + { + free (compressed_buffer); + bfd_set_error (bfd_error_bad_value); + return FALSE; + } + + /* Write the zlib header. In this case, it should be "ZLIB" followed + by the uncompressed section size, 8 bytes in big-endian order. */ + memcpy (compressed_buffer, "ZLIB", 4); + compressed_buffer[11] = uncompressed_size; uncompressed_size >>= 8; + compressed_buffer[10] = uncompressed_size; uncompressed_size >>= 8; + compressed_buffer[9] = uncompressed_size; uncompressed_size >>= 8; + compressed_buffer[8] = uncompressed_size; uncompressed_size >>= 8; + compressed_buffer[7] = uncompressed_size; uncompressed_size >>= 8; + compressed_buffer[6] = uncompressed_size; uncompressed_size >>= 8; + compressed_buffer[5] = uncompressed_size; uncompressed_size >>= 8; + compressed_buffer[4] = uncompressed_size; + compressed_size += 12; + + /* Free the uncompressed contents if we compress in place. */ + if (uncompressed_buffer == sec->contents) + free (uncompressed_buffer); + + sec->contents = compressed_buffer; + sec->size = compressed_size; + sec->compress_status = COMPRESS_SECTION_DONE; + + return TRUE; +#endif /* HAVE_ZLIB_H */ +} + +/* +FUNCTION + bfd_get_full_section_contents + +SYNOPSIS + bfd_boolean bfd_get_full_section_contents + (bfd *abfd, asection *section, bfd_byte **ptr); + +DESCRIPTION + Read all data from @var{section} in BFD @var{abfd}, decompress + if needed, and store in @var{*ptr}. If @var{*ptr} is NULL, + return @var{*ptr} with memory malloc'd by this function. + + Return @code{TRUE} if the full section contents is retrieved + successfully. +*/ + +bfd_boolean +bfd_get_full_section_contents (bfd *abfd, sec_ptr sec, bfd_byte **ptr) +{ + bfd_size_type sz = sec->rawsize ? sec->rawsize : sec->size; + bfd_byte *p = *ptr; + bfd_boolean need_free, ret; +#ifdef HAVE_ZLIB_H + bfd_size_type compressed_size; bfd_size_type uncompressed_size; + bfd_size_type rawsize; + bfd_byte *compressed_buffer; bfd_byte *uncompressed_buffer; - z_stream strm; - int rc; - bfd_size_type header_size = 12; +#endif + + if (sz == 0) + return TRUE; + + switch (sec->compress_status) + { + case COMPRESS_SECTION_NONE: + if (p == NULL) + { + p = (bfd_byte *) bfd_malloc (sz); + if (p == NULL) + return FALSE; + need_free = TRUE; + *ptr = p; + } + else + need_free = FALSE; + ret = bfd_get_section_contents (abfd, sec, p, 0, sz); + if (!ret && need_free) + free (p); + return ret; + + case COMPRESS_SECTION_DONE: + if (p) + memcpy (p, sec->contents, sz); + else + *ptr = sec->contents; + return TRUE; + + case DECOMPRESS_SECTION_SIZED: + break; + + default: + abort (); + } + +#ifndef HAVE_ZLIB_H + bfd_set_error (bfd_error_invalid_operation); + return FALSE; +#else + /* Read in the full compressed section contents. */ + uncompressed_size = sec->size; + compressed_size = sec->compressed_size; + compressed_buffer = (bfd_byte *) bfd_malloc (compressed_size); + rawsize = sec->rawsize; + /* Clear rawsize, set size to compressed size and set compress_status + to COMPRESS_SECTION_NONE. If the compressed size is bigger than + the uncompressed size, bfd_get_section_contents will fail. */ + sec->rawsize = 0; + sec->size = compressed_size; + sec->compress_status = COMPRESS_SECTION_NONE; + ret = bfd_get_section_contents (abfd, sec, compressed_buffer, + 0, compressed_size); + /* Restore rawsize and size. */ + sec->rawsize = rawsize; + sec->size = uncompressed_size; + if (!ret) + { +fail_compressed: + sec->compress_status = DECOMPRESS_SECTION_SIZED; + free (compressed_buffer); + return ret; + } + + /* Decompress to caller buffer directly if it is provided. */ + if (p) + uncompressed_buffer = p; + else + { + uncompressed_buffer = (bfd_byte *) bfd_malloc (uncompressed_size); + if (uncompressed_buffer == NULL) + goto fail_compressed; + } + + if (!decompress_contents (compressed_buffer, compressed_size, + uncompressed_buffer, uncompressed_size)) + { + sec->compress_status = DECOMPRESS_SECTION_SIZED; + free (compressed_buffer); + if (p == NULL) + free (uncompressed_buffer); + bfd_set_error (bfd_error_bad_value); + return FALSE; + } + + free (compressed_buffer); + if (p == NULL) + *ptr = uncompressed_buffer; + + sec->contents = uncompressed_buffer; + sec->compress_status = COMPRESS_SECTION_DONE; + + return TRUE; +#endif +} + +/* +FUNCTION + bfd_is_section_compressed + +SYNOPSIS + bfd_boolean bfd_is_section_compressed + (bfd *abfd, asection *section); + +DESCRIPTION + Return @code{TRUE} if @var{section} is compressed. +*/ + +bfd_boolean +bfd_is_section_compressed (bfd *abfd, sec_ptr sec) +{ + bfd_byte compressed_buffer [12]; + + /* Read the zlib header. In this case, it should be "ZLIB" followed + by the uncompressed section size, 8 bytes in big-endian order. */ + return (bfd_get_section_contents (abfd, sec, compressed_buffer, 0, 12) + && CONST_STRNEQ ((char*) compressed_buffer, "ZLIB")); +} + +/* +FUNCTION + bfd_init_section_decompress_status + +SYNOPSIS + bfd_boolean bfd_init_section_decompress_status + (bfd *abfd, asection *section); + +DESCRIPTION + Record compressed section size, update section size with + decompressed size and set compress_status to + 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}. +*/ + +bfd_boolean +bfd_init_section_decompress_status (bfd *abfd ATTRIBUTE_UNUSED, + sec_ptr sec ATTRIBUTE_UNUSED) +{ +#ifndef HAVE_ZLIB_H + bfd_set_error (bfd_error_invalid_operation); + return FALSE; +#else + bfd_byte compressed_buffer [12]; + bfd_size_type uncompressed_size; + + if (sec->rawsize != 0 + || sec->contents != NULL + || sec->compress_status != COMPRESS_SECTION_NONE + || !bfd_get_section_contents (abfd, sec, compressed_buffer, 0, 12)) + { + bfd_set_error (bfd_error_invalid_operation); + 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 (compressed_size < header_size - || ! CONST_STRNEQ ((char*) compressed_buffer, "ZLIB")) - return FALSE; + if (! CONST_STRNEQ ((char*) compressed_buffer, "ZLIB")) + { + bfd_set_error (bfd_error_wrong_format); + return FALSE; + } + uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8; uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8; uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8; @@ -79,42 +339,66 @@ bfd_uncompress_section_contents (bfd_byte **buffer ATTRIBUTE_UNUSED, uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8; uncompressed_size += compressed_buffer[11]; - /* 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 - header_size; - strm.next_in = (Bytef*) compressed_buffer + header_size; - strm.avail_out = uncompressed_size; - uncompressed_buffer = (bfd_byte *) bfd_malloc (uncompressed_size); - if (! uncompressed_buffer) - return FALSE; + sec->compressed_size = sec->size; + sec->size = uncompressed_size; + sec->compress_status = DECOMPRESS_SECTION_SIZED; - rc = inflateInit (&strm); - while (strm.avail_in > 0) + return TRUE; +#endif +} + +/* +FUNCTION + bfd_init_section_compress_status + +SYNOPSIS + bfd_boolean bfd_init_section_compress_status + (bfd *abfd, asection *section); + +DESCRIPTION + If open for read, compress section, update section size with + 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}. +*/ + +bfd_boolean +bfd_init_section_compress_status (bfd *abfd ATTRIBUTE_UNUSED, + sec_ptr sec ATTRIBUTE_UNUSED) +{ +#ifndef HAVE_ZLIB_H + bfd_set_error (bfd_error_invalid_operation); + return FALSE; +#else + bfd_size_type uncompressed_size; + bfd_byte *uncompressed_buffer; + bfd_boolean ret; + + /* Error if not opened for read. */ + if (abfd->direction != read_direction + || sec->size == 0 + || sec->rawsize != 0 + || sec->contents != NULL + || sec->compress_status != COMPRESS_SECTION_NONE) { - if (rc != Z_OK) - goto fail; - strm.next_out = ((Bytef*) uncompressed_buffer - + (uncompressed_size - strm.avail_out)); - rc = inflate (&strm, Z_FINISH); - if (rc != Z_STREAM_END) - goto fail; - rc = inflateReset (&strm); + bfd_set_error (bfd_error_invalid_operation); + return FALSE; } - rc = inflateEnd (&strm); - if (rc != Z_OK - || strm.avail_out != 0) - goto fail; - free (compressed_buffer); - *buffer = uncompressed_buffer; - *size = uncompressed_size; - return TRUE; + /* Read in the full section contents and compress it. */ + uncompressed_size = sec->size; + uncompressed_buffer = (bfd_byte *) bfd_malloc (uncompressed_size); + if (!bfd_get_section_contents (abfd, sec, uncompressed_buffer, + 0, uncompressed_size)) + ret = FALSE; + else + ret = bfd_compress_section_contents (abfd, sec, + uncompressed_buffer, + uncompressed_size); - fail: free (uncompressed_buffer); - return FALSE; -#endif /* HAVE_ZLIB_H */ + return ret; +#endif }