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.

1 files changed, 207 insertions, 58 deletions

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;
 }