From 151411f8af16723a12e0e0eedc1ecdbea648c1b0 Mon Sep 17 00:00:00 2001 From: "H.J. Lu" Date: Wed, 8 Apr 2015 07:53:54 -0700 Subject: Add SHF_COMPRESSED support to gas and objcopy This patch adds --compress-debug-sections={none|zlib|zlib-gnu|zlib-gabi} options to gas and objcopy for ELF files. They control how DWARF debug sections are compressed. --compress-debug-sections=none is equivalent to --nocompress-debug-sections. --compress-debug-sections=zlib and --compress-debug-sections=zlib-gnu are equivalent to --compress-debug-sections. --compress-debug-sections=zlib-gabi compresses DWARF debug sections with SHF_COMPRESSED from the ELF ABI. No linker changes are required to support SHF_COMPRESSED. bfd/ * archive.c (_bfd_get_elt_at_filepos): Also copy BFD_COMPRESS_GABI bit. * bfd.c (bfd::flags): Increase size to 18 bits. (BFD_COMPRESS_GABI): New. (BFD_FLAGS_SAVED): Add BFD_COMPRESS_GABI. (BFD_FLAGS_FOR_BFD_USE_MASK): Likewise. (bfd_update_compression_header): New fuction. (bfd_check_compression_header): Likewise. (bfd_get_compression_header_size): Likewise. (bfd_is_section_compressed_with_header): Likewise. * compress.c (MAX_COMPRESSION_HEADER_SIZE): New. (bfd_compress_section_contents): Return the uncompressed size if the full section contents is compressed successfully. Support converting from/to .zdebug* sections. (bfd_get_full_section_contents): Call bfd_get_compression_header_size to get compression header size. (bfd_is_section_compressed): Renamed to ... (bfd_is_section_compressed_with_header): This. Add a pointer argument to return compression header size. (bfd_is_section_compressed): Use it. (bfd_init_section_decompress_status): Call bfd_get_compression_header_size to get compression header size. Return FALSE if uncompressed section size is 0. * elf.c (_bfd_elf_make_section_from_shdr): Support converting from/to .zdebug* sections. * bfd-in2.h: Regenerated. binutils/ * objcopy.c (do_debug_sections): Add compress_zlib, compress_gnu_zlib and compress_gabi_zlib. (copy_options): Use optional_argument on compress-debug-sections. (copy_usage): Update --compress-debug-sections. (copy_file): Handle compress_zlib, compress_gnu_zlib and compress_gabi_zlib. (copy_main): Handle --compress-debug-sections={none|zlib|zlib-gnu|zlib-gabi}. * doc/binutils.texi: Document --compress-debug-sections={none|zlib|zlib-gnu|zlib-gabi}. binutils/testsuite/ * compress.exp: Add tests for --compress-debug-sections={none|zlib|zlib-gnu|zlib-gabi}. * binutils-all/dw2-3.rS: New file. * binutils-all/dw2-3.rt: Likewise. * binutils-all/libdw2-compressedgabi.out: Likewise. gas/ * as.c (show_usage): Update --compress-debug-sections. (std_longopts): Use optional_argument on compress-debug-sections. (parse_args): Handle --compress-debug-sections={none|zlib|zlib-gnu|zlib-gabi}. * as.h (compressed_debug_section_type): New. (flag_compress_debug): Change type to compressed_debug_section_type. --compress-debug-sections={none|zlib|zlib-gnu|zlib-gabi}. * write.c (compress_debug): Set BFD_COMPRESS_GABI for --compress-debug-sections=zlib-gabi. Call bfd_get_compression_header_size to get compression header size. Don't rename section name for --compress-debug-sections=zlib-gabi. * config/tc-i386.c (compressed_debug_section_type): Set to COMPRESS_DEBUG_ZLIB. * doc/as.texinfo: Document --compress-debug-sections={none|zlib|zlib-gnu|zlib-gabi}. gas/testsuite/ * gas/i386/dw2-compressed-1.d: New file. * gas/i386/dw2-compressed-2.d: Likewise. * gas/i386/dw2-compressed-3.d: Likewise. * gas/i386/x86-64-dw2-compressed-2.d: Likewise. * gas/i386/i386.exp: Run dw2-compressed-2, dw2-compressed-1, dw2-compressed-3 and x86-64-dw2-compressed-2. ld/testsuite/ * ld-elf/compress.exp: Add a test for --compress-debug-sections=zlib-gabi. (build_tests): Add 2 tests for --compress-debug-sections=zlib-gabi. (run_tests): Likewise. Verify linker output with zlib-gabi compressed debug input. * ld-elf/compressed1a.d: New file. * ld-elf/compressed1b.d: Likewise. * ld-elf/compressed1c.d: Likewise. --- bfd/compress.c | 265 ++++++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 207 insertions(+), 58 deletions(-) (limited to 'bfd/compress.c') diff --git a/bfd/compress.c b/bfd/compress.c index b57650f..ba9fc96 100644 --- a/bfd/compress.c +++ b/bfd/compress.c @@ -24,6 +24,8 @@ #include "libbfd.h" #include "safe-ctype.h" +#define MAX_COMPRESSION_HEADER_SIZE 24 + static bfd_boolean decompress_contents (bfd_byte *compressed_buffer, bfd_size_type compressed_size, @@ -65,55 +67,136 @@ decompress_contents (bfd_byte *compressed_buffer, 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. */ + Return the uncompressed size if the full section contents is + compressed successfully. Otherwise return 0. */ -static bfd_boolean -bfd_compress_section_contents (bfd *abfd ATTRIBUTE_UNUSED, sec_ptr sec, +static bfd_size_type +bfd_compress_section_contents (bfd *abfd, sec_ptr sec, bfd_byte *uncompressed_buffer, bfd_size_type uncompressed_size) { uLong compressed_size; - bfd_byte *compressed_buffer; - - compressed_size = compressBound (uncompressed_size) + 12; - compressed_buffer = (bfd_byte *) bfd_malloc (compressed_size); + bfd_byte *buffer; + bfd_size_type buffer_size; + bfd_boolean decompress; + int zlib_size; + int orig_compression_header_size; + int compression_header_size + = bfd_get_compression_header_size (abfd, NULL); + bfd_boolean compressed + = bfd_is_section_compressed_with_header (abfd, sec, + &orig_compression_header_size); + + if (compressed) + { + /* We shouldn't decompress unsupported compressed section. */ + if (orig_compression_header_size < 0) + abort (); - if (compressed_buffer == NULL) - return FALSE; + /* Different compression schemes. Just move the compressed section + contents to the right position. */ + 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); + } + else + { + /* Convert it to .zdebug* section. */ + zlib_size = uncompressed_size - orig_compression_header_size; + compressed_size = zlib_size; + } + } + else + compressed_size = compressBound (uncompressed_size) + 12; - if (compress ((Bytef*) compressed_buffer + 12, - &compressed_size, - (const Bytef*) uncompressed_buffer, - uncompressed_size) != Z_OK) + /* When converting from .zdebug* section, uncompress if it leads to + smaller size. */ + if (compressed + && orig_compression_header_size == 0 + && compressed_size > uncompressed_size) { - free (compressed_buffer); - bfd_set_error (bfd_error_bad_value); - return FALSE; + decompress = TRUE; + buffer_size = uncompressed_size; } + else + { + decompress = FALSE; + buffer_size = compressed_size + compression_header_size; + } + buffer = (bfd_byte *) bfd_malloc (buffer_size); + if (buffer == NULL) + return 0; - compressed_size += 12; - - /* PR binutils/18087: If compression didn't make the section smaller, - just keep it uncompressed. */ - if (compressed_size < uncompressed_size) + if (compressed) { - /* 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); - bfd_putb64 (uncompressed_size, compressed_buffer + 4); - free (uncompressed_buffer); - sec->contents = compressed_buffer; - sec->size = compressed_size; - sec->compress_status = COMPRESS_SECTION_DONE; + sec->size = uncompressed_size; + if (decompress) + { + if (!decompress_contents (uncompressed_buffer, zlib_size, + buffer, uncompressed_size)) + { + bfd_set_error (bfd_error_bad_value); + free (buffer); + return 0; + } + free (uncompressed_buffer); + sec->contents = buffer; + sec->compress_status = COMPRESS_SECTION_DONE; + return uncompressed_size; + } + else + { + bfd_update_compression_header (abfd, buffer, sec); + memmove (buffer + compression_header_size, + uncompressed_buffer + orig_compression_header_size, + zlib_size); + } } else { - sec->contents = uncompressed_buffer; - sec->compress_status = COMPRESS_SECTION_NONE; + 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_set_error (bfd_error_bad_value); + return 0; + } + + compressed_size += header_size; + /* 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); + } + else + { + sec->contents = uncompressed_buffer; + sec->compress_status = COMPRESS_SECTION_NONE; + return uncompressed_size; + } } - return TRUE; + free (uncompressed_buffer); + sec->contents = buffer; + sec->size = compressed_size; + sec->compress_status = COMPRESS_SECTION_DONE; + + return uncompressed_size; } /* @@ -143,6 +226,7 @@ bfd_get_full_section_contents (bfd *abfd, sec_ptr sec, bfd_byte **ptr) bfd_size_type save_size; bfd_size_type save_rawsize; bfd_byte *compressed_buffer; + unsigned int compression_header_size; if (abfd->direction != write_direction && sec->rawsize != 0) sz = sec->rawsize; @@ -200,7 +284,9 @@ bfd_get_full_section_contents (bfd *abfd, sec_ptr sec, bfd_byte **ptr) if (p == NULL) goto fail_compressed; - if (!decompress_contents (compressed_buffer, sec->compressed_size, p, sz)) + compression_header_size = bfd_get_compression_header_size (abfd, sec); + if (!decompress_contents (compressed_buffer + compression_header_size, + sec->compressed_size, p, sz)) { bfd_set_error (bfd_error_bad_value); if (p != *ptr) @@ -256,50 +342,96 @@ bfd_cache_section_contents (asection *sec, void *contents) sec->flags |= SEC_IN_MEMORY; } - /* FUNCTION - bfd_is_section_compressed + bfd_is_section_compressed_with_header SYNOPSIS - bfd_boolean bfd_is_section_compressed - (bfd *abfd, asection *section); + bfd_boolean bfd_is_section_compressed_with_header + (bfd *abfd, asection *section, + int *compression_header_size_p); DESCRIPTION - Return @code{TRUE} if @var{section} is compressed. + 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. */ bfd_boolean -bfd_is_section_compressed (bfd *abfd, sec_ptr sec) +bfd_is_section_compressed_with_header (bfd *abfd, sec_ptr sec, + int *compression_header_size_p) { - bfd_byte compressed_buffer [12]; + bfd_byte header[MAX_COMPRESSION_HEADER_SIZE + 12]; + int compression_header_size; + int header_size = 12; unsigned int saved = sec->compress_status; bfd_boolean compressed; + compression_header_size = bfd_get_compression_header_size (abfd, sec); + if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE) + abort (); + header_size += compression_header_size; + /* 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, compressed_buffer, 0, 12) - && CONST_STRNEQ ((char*) compressed_buffer, "ZLIB")); + compressed = bfd_get_section_contents (abfd, sec, header, 0, + header_size) + && CONST_STRNEQ ((char*) header + compression_header_size, + "ZLIB"); - /* Check for the pathalogical case of a debug string section that - contains the string ZLIB.... as the first entry. We assume that - no uncompressed .debug_str section would ever be big enough to - have the first byte of its (big-endian) size be non-zero. */ - if (compressed - && strcmp (sec->name, ".debug_str") == 0 - && ISPRINT (compressed_buffer[4])) - compressed = FALSE; + 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)) + compression_header_size = -1; + } + /* Check for the pathalogical case of a debug string section that + contains the string ZLIB.... as the first entry. We assume that + 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])) + compressed = FALSE; + } /* Restore compress_status. */ sec->compress_status = saved; + *compression_header_size_p = compression_header_size; return compressed; } /* 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) +{ + int compression_header_size; + return (bfd_is_section_compressed_with_header (abfd, sec, + &compression_header_size) + && compression_header_size >= 0); +} + +/* +FUNCTION bfd_init_section_decompress_status SYNOPSIS @@ -319,13 +451,20 @@ DESCRIPTION bfd_boolean bfd_init_section_decompress_status (bfd *abfd, sec_ptr sec) { - bfd_byte compressed_buffer [12]; + bfd_byte header[MAX_COMPRESSION_HEADER_SIZE + 12]; + int compression_header_size; + int header_size = 12; bfd_size_type uncompressed_size; + compression_header_size = bfd_get_compression_header_size (abfd, sec); + if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE) + abort (); + header_size += compression_header_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_get_section_contents (abfd, sec, header, 0, header_size)) { bfd_set_error (bfd_error_invalid_operation); return FALSE; @@ -333,13 +472,20 @@ bfd_init_section_decompress_status (bfd *abfd, sec_ptr sec) /* 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*) compressed_buffer, "ZLIB")) + if (! CONST_STRNEQ ((char*) header + compression_header_size, "ZLIB")) { bfd_set_error (bfd_error_wrong_format); return FALSE; } - uncompressed_size = bfd_getb64 (compressed_buffer + 4); + uncompressed_size = bfd_getb64 (header + compression_header_size + 4); + if (compression_header_size != 0 + && !bfd_check_compression_header (abfd, header, sec, + uncompressed_size)) + { + bfd_set_error (bfd_error_wrong_format); + return FALSE; + } sec->compressed_size = sec->size; sec->size = uncompressed_size; sec->compress_status = DECOMPRESS_SECTION_SIZED; @@ -389,9 +535,12 @@ bfd_init_section_compress_status (bfd *abfd, sec_ptr sec) 0, uncompressed_size)) ret = FALSE; else - ret = bfd_compress_section_contents (abfd, sec, - uncompressed_buffer, - uncompressed_size); + { + uncompressed_size = bfd_compress_section_contents (abfd, sec, + uncompressed_buffer, + uncompressed_size); + ret = uncompressed_size != 0; + } return ret; } -- cgit v1.1