From 68c19cc2eb92a1a44b6e5b6465f9315b4e5266e0 Mon Sep 17 00:00:00 2001 From: "H.J. Lu" Date: Fri, 29 Oct 2010 12:10:19 +0000 Subject: Add compressed debug section support to binutils and ld. bfd/ 2010-10-29 H.J. Lu Cary Coutant * archive.c (bfd_openr_next_archived_file): Copy BFD_COMPRESS and BFD_DECOMPRESS. * bfd.c (BFD_COMPRESS): New. (BFD_DECOMPRESS): Likewise. (BFD_FLAGS_SAVED): Likewise. (bfd_preserve_save): Replace BFD_IN_MEMORY with BFD_FLAGS_SAVED. * compress.c (bfd_uncompress_section_contents): Removed. (get_uncompressed_size): New. (decompress_contents): Likewise. (bfd_compress_section_contents): Likewise. (bfd_get_full_section_contents): Likewise. (bfd_is_section_compressed): Likewise. (bfd_init_section_decompress_status): Likewise. (bfd_init_section_compress_status): Likewise. * dwarf2.c (dwarf_debug_sections): New. (dwarf_debug_section_enum): Likewise. (read_section): Remove section_name and compressed_section_name. Add dwarf_debug_section_enum. Try compressed debug section. (read_indirect_string): Updated. (read_abbrevs): Likewise. (decode_line_info): Likewise. (read_debug_ranges): Likewise. (find_line): Updated. * ecoff.c (bfd_debug_section): Add compress_status and compressed_size. * elf.c (_bfd_elf_make_section_from_shdr): Call bfd_is_section_compressed to check if a DWARF debug section is compressed. Call bfd_init_section_compress_status or bfd_init_section_decompress_status if needed. * elflink.c (elf_link_input_bfd): Replace bfd_get_section_contents with bfd_get_full_section_contents. * merge.c (_bfd_add_merge_section): Likewise. * reloc.c (bfd_generic_get_relocated_section_contents): Likewise. * simple.c (bfd_simple_get_relocated_section_contents): Likewise. * elfxx-target.h (TARGET_BIG_SYM): Allow BFD_COMPRESS and BFD_DECOMPRESS. (TARGET_LITTLE_SYM): Likewise. * libbfd-in.h (dwarf_debug_section): New. (dwarf_debug_sections): Likewise. * libbfd.c (_bfd_generic_get_section_contents): Issue an error when getting contents on compressed/decompressed section. * section.c (COMPRESS_SECTION_NONE): New. (COMPRESS_SECTION_DONE): Likewise. (DECOMPRESS_SECTION_SIZED): Likewise. (BFD_FAKE_SECTION): Add compress_status and compressed_size. (bfd_malloc_and_get_section): Replace bfd_get_section_contents with bfd_get_full_section_contents. * bfd-in2.h: Regenerated. * libbfd.h: Likewise. binutils/ 2010-10-29 H.J. Lu * addr2line.c (process_file): Set BFD_DECOMPRESS. * objcopy.c (do_debug_sections): New. (OPTION_COMPRESS_DEBUG_SECTIONS): New. (OPTION_DECOMPRESS_DEBUG_SECTIONS): Likewise. (copy_options): Add OPTION_COMPRESS_DEBUG_SECTIONS and OPTION_DECOMPRESS_DEBUG_SECTIONS. (copy_usage): Add --compress-debug-sections and --decompress-debug-sections. (copy_file): Set BFD_COMPRESS or BFD_DECOMPRESS. (copy_section): Replace bfd_get_section_contents with bfd_get_full_section_contents. (copy_main): Handle OPTION_COMPRESS_DEBUG_SECTIONS and OPTION_DECOMPRESS_DEBUG_SECTIONS. Check do_debug_sections to rename DWARF debug sections. * objdump.c (load_specific_debug_section): Replace bfd_get_section_contents with bfd_get_full_section_contents. Remove bfd_uncompress_section_contents. (dump_section): Replace bfd_get_section_contents with bfd_get_full_section_contents. (display_file): Set BFD_DECOMPRESS if needed. * readelf.c (uncompress_section_contents): Set buffer to NULL to indiate decompression failure. (load_specific_debug_section): Always call uncompress_section_contents. * doc/binutils.texi: Document --compress-debug-sections and --decompress-debug-sections. binutils/testsuite/ 2010-10-29 H.J. Lu * binutils-all/compress.exp: New. * binutils-all/dw2-1.S: Likewise. * binutils-all/dw2-2.S: Likewise. * binutils-all/libdw2-compressed.out: Likewise. * binutils-all/libdw2.out: Likewise. gas/ 2010-10-29 H.J. Lu * write.c (compress_debug): Optimize section flags check. gas/testsuite/ 2010-10-29 H.J. Lu * elf/dwarf2-1.s: Replace .zdebug_abbrev section with .debug_abbrev section. * elf/dwarf2-2.3: Likewise. * elf/dwarf2-1.d: Pass --compress-debug-sections to assembler. Updated. * elf/dwarf2-2.d: Likewise. * gas/i386/i386.exp: Remove xfail on dw2-compress-2 and x86-64-dw2-compress-2. ld/ 2010-10-29 H.J. Lu * ldfile.c (ldfile_try_open_bfd): Set BFD_DECOMPRESS after bfd_openr returns. * emultempl/elf32.em (gld${EMULATION_NAME}_try_needed): Likewise. * scripttempl/elf.sc: Include compressed DWARF debug sections. ld/testsuite/ 2010-10-29 H.J. Lu * ld-elf/compress.exp: New. * ld-elf/compress1.s: Likewise. * ld-elf/compress1a.d: Likewise. * ld-elf/compress1b.d: Likewise. * ld-elf/compress1c.d: Likewise. --- bfd/compress.c | 396 +++++++++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 340 insertions(+), 56 deletions(-) (limited to 'bfd/compress.c') diff --git a/bfd/compress.c b/bfd/compress.c index fe1b0fd3b33..171de77f38e 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 } -- cgit v1.2.1