[deliverable/binutils-gdb.git] / bfd / compress.c

/* Compressed section support (intended for debug sections).
   Copyright (C) 2008-2015 Free Software Foundation, Inc.

   This file is part of BFD, the Binary File Descriptor library.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */

#include "sysdep.h"
#include <zlib.h>
#include "bfd.h"
#include "libbfd.h"
#include "safe-ctype.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;

  BFD_ASSERT (Z_OK == 0);
  rc = inflateInit (&strm);
  while (strm.avail_in > 0 && strm.avail_out > 0)
    {
      if (rc != Z_OK)
	break;
      strm.next_out = ((Bytef*) uncompressed_buffer
                       + (uncompressed_size - strm.avail_out));
      rc = inflate (&strm, Z_FINISH);
      if (rc != Z_STREAM_END)
	break;
      rc = inflateReset (&strm);
    }
  rc |= inflateEnd (&strm);
  return rc == Z_OK && strm.avail_out == 0;
}

/* 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.  */

static bfd_boolean
bfd_compress_section_contents (bfd *abfd ATTRIBUTE_UNUSED, 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);

  if (compressed_buffer == NULL)
    return FALSE;

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

  compressed_size += 12;

  /* PR binutils/18087: If compression didn't make the section smaller,
     just keep it uncompressed.  */
  if (compressed_size < uncompressed_size)
    {
      /* 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;
    }
  else
    {
      sec->contents = uncompressed_buffer;
      sec->compress_status = COMPRESS_SECTION_NONE;
    }

  return TRUE;
}

/*
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.  If the section has no contents then this function
	returns @code{TRUE} but @var{*ptr} is set to NULL.
*/

bfd_boolean
bfd_get_full_section_contents (bfd *abfd, sec_ptr sec, bfd_byte **ptr)
{
  bfd_size_type sz;
  bfd_byte *p = *ptr;
  bfd_boolean ret;
  bfd_size_type save_size;
  bfd_size_type save_rawsize;
  bfd_byte *compressed_buffer;

  if (abfd->direction != write_direction && sec->rawsize != 0)
    sz = sec->rawsize;
  else
    sz = sec->size;
  if (sz == 0)
    {
      *ptr = NULL;
      return TRUE;
    }

  switch (sec->compress_status)
    {
    case COMPRESS_SECTION_NONE:
      if (p == NULL)
	{
	  p = (bfd_byte *) bfd_malloc (sz);
	  if (p == NULL)
	    return FALSE;
	}

      if (!bfd_get_section_contents (abfd, sec, p, 0, sz))
	{
	  if (*ptr != p)
	    free (p);
	  return FALSE;
	}
      *ptr = p;
      return TRUE;

    case DECOMPRESS_SECTION_SIZED:
      /* Read in the full compressed section contents.  */
      compressed_buffer = (bfd_byte *) bfd_malloc (sec->compressed_size);
      if (compressed_buffer == NULL)
	return FALSE;
      save_rawsize = sec->rawsize;
      save_size = sec->size;
      /* 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 = sec->compressed_size;
      sec->compress_status = COMPRESS_SECTION_NONE;
      ret = bfd_get_section_contents (abfd, sec, compressed_buffer,
				      0, sec->compressed_size);
      /* Restore rawsize and size.  */
      sec->rawsize = save_rawsize;
      sec->size = save_size;
      sec->compress_status = DECOMPRESS_SECTION_SIZED;
      if (!ret)
	goto fail_compressed;

      if (p == NULL)
	p = (bfd_byte *) bfd_malloc (sz);
      if (p == NULL)
	goto fail_compressed;

      if (!decompress_contents (compressed_buffer, sec->compressed_size, p, sz))
	{
	  bfd_set_error (bfd_error_bad_value);
	  if (p != *ptr)
	    free (p);
	fail_compressed:
	  free (compressed_buffer);
	  return FALSE;
	}

      free (compressed_buffer);
      *ptr = p;
      return TRUE;

    case COMPRESS_SECTION_DONE:
      if (sec->contents == NULL)
	return FALSE;
      if (p == NULL)
	{
	  p = (bfd_byte *) bfd_malloc (sz);
	  if (p == NULL)
	    return FALSE;
	  *ptr = p;
	}
      /* PR 17512; file: 5bc29788.  */
      if (p != sec->contents)
	memcpy (p, sec->contents, sz);
      return TRUE;

    default:
      abort ();
    }
}

/*
FUNCTION
	bfd_cache_section_contents

SYNOPSIS
	void bfd_cache_section_contents
	  (asection *sec, void *contents);

DESCRIPTION
	Stash @var(contents) so any following reads of @var(sec) do
	not need to decompress again.
*/

void
bfd_cache_section_contents (asection *sec, void *contents)
{
  if (sec->compress_status == DECOMPRESS_SECTION_SIZED)
    sec->compress_status = COMPRESS_SECTION_DONE;
  sec->contents = contents;
  sec->flags |= SEC_IN_MEMORY;
}


/*
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];
  unsigned int saved = sec->compress_status;
  bfd_boolean compressed;

  /* 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"));

  /* 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;

  /* Restore compress_status.  */
  sec->compress_status = saved;
  return compressed;
}

/*
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, sec_ptr sec)
{
  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 (! CONST_STRNEQ ((char*) compressed_buffer, "ZLIB"))
    {
      bfd_set_error (bfd_error_wrong_format);
      return FALSE;
    }

  uncompressed_size = bfd_getb64 (compressed_buffer + 4);
  sec->compressed_size = sec->size;
  sec->size = uncompressed_size;
  sec->compress_status = DECOMPRESS_SECTION_SIZED;

  return TRUE;
}

/*
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, 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
      || sec->size == 0
      || sec->rawsize != 0
      || sec->contents != NULL
      || sec->compress_status != COMPRESS_SECTION_NONE)
    {
      bfd_set_error (bfd_error_invalid_operation);
      return FALSE;
    }

  /* 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);

  return ret;
}
Commit	Line	Data
0acf065b	1	/* Compressed section support (intended for debug sections).
b90efa5b	2	Copyright (C) 2008-2015 Free Software Foundation, Inc.
1b315056 CS	3
	4	This file is part of BFD, the Binary File Descriptor library.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 3 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
	19	MA 02110-1301, USA. */
	20
1b315056	21	#include "sysdep.h"
243340ad	22	#include <zlib.h>
1b315056 CS	23	#include "bfd.h"
1b315056 CS	24	#include "libbfd.h"
a953eec9	25	#include "safe-ctype.h"
1b315056	26
4a114e3e L	27	static bfd_boolean
	28	decompress_contents (bfd_byte *compressed_buffer,
	29	bfd_size_type compressed_size,
	30	bfd_byte *uncompressed_buffer,
	31	bfd_size_type uncompressed_size)
	32	{
	33	z_stream strm;
	34	int rc;
	35
	36	/* It is possible the section consists of several compressed
	37	buffers concatenated together, so we uncompress in a loop. */
	38	strm.zalloc = NULL;
	39	strm.zfree = NULL;
	40	strm.opaque = NULL;
	41	strm.avail_in = compressed_size - 12;
	42	strm.next_in = (Bytef*) compressed_buffer + 12;
	43	strm.avail_out = uncompressed_size;
	44
a253d456	45	BFD_ASSERT (Z_OK == 0);
4a114e3e	46	rc = inflateInit (&strm);
a29a8af8	47	while (strm.avail_in > 0 && strm.avail_out > 0)
4a114e3e L	48	{
4a114e3e L	49	if (rc != Z_OK)
a253d456	50	break;
4a114e3e L	51	strm.next_out = ((Bytef*) uncompressed_buffer
	52	+ (uncompressed_size - strm.avail_out));
	53	rc = inflate (&strm, Z_FINISH);
	54	if (rc != Z_STREAM_END)
a253d456	55	break;
4a114e3e L	56	rc = inflateReset (&strm);
4a114e3e L	57	}
a253d456	58	rc \|= inflateEnd (&strm);
82c6068a	59	return rc == Z_OK && strm.avail_out == 0;
4a114e3e	60	}
4a114e3e	61
0b0732e1 L	62	/* Compress data of the size specified in @var{uncompressed_size}
	63	and pointed to by @var{uncompressed_buffer} using zlib and store
	64	as the contents field. This function assumes the contents
	65	field was allocated using bfd_malloc() or equivalent. If zlib
	66	is not installed on this machine, the input is unmodified.
1b315056	67
0b0732e1 L	68	Return @code{TRUE} if the full section contents is compressed
0b0732e1 L	69	successfully. */
1b315056	70
0b0732e1	71	static bfd_boolean
243340ad L	72	bfd_compress_section_contents (bfd *abfd ATTRIBUTE_UNUSED, sec_ptr sec,
	73	bfd_byte *uncompressed_buffer,
	74	bfd_size_type uncompressed_size)
1b315056	75	{
ae6a0217	76	uLong compressed_size;
4a114e3e L	77	bfd_byte *compressed_buffer;
	78
	79	compressed_size = compressBound (uncompressed_size) + 12;
	80	compressed_buffer = (bfd_byte *) bfd_malloc (compressed_size);
	81
4281caad MS	82	if (compressed_buffer == NULL)
	83	return FALSE;
	84
4a114e3e L	85	if (compress ((Bytef*) compressed_buffer + 12,
	86	&compressed_size,
	87	(const Bytef*) uncompressed_buffer,
	88	uncompressed_size) != Z_OK)
	89	{
	90	free (compressed_buffer);
	91	bfd_set_error (bfd_error_bad_value);
	92	return FALSE;
	93	}
	94
4a114e3e L	95	compressed_size += 12;
4a114e3e L	96
8d001214 L	97	/* PR binutils/18087: If compression didn't make the section smaller,
	98	just keep it uncompressed. */
	99	if (compressed_size < uncompressed_size)
	100	{
	101	/* Write the zlib header. In this case, it should be "ZLIB" followed
	102	by the uncompressed section size, 8 bytes in big-endian order. */
	103	memcpy (compressed_buffer, "ZLIB", 4);
4aa90cc0	104	bfd_putb64 (uncompressed_size, compressed_buffer + 4);
8d001214 L	105	free (uncompressed_buffer);
	106	sec->contents = compressed_buffer;
	107	sec->size = compressed_size;
	108	sec->compress_status = COMPRESS_SECTION_DONE;
	109	}
	110	else
	111	{
	112	sec->contents = uncompressed_buffer;
	113	sec->compress_status = COMPRESS_SECTION_NONE;
	114	}
4a114e3e L	115
4a114e3e L	116	return TRUE;
4a114e3e L	117	}
	118
	119	/*
	120	FUNCTION
	121	bfd_get_full_section_contents
	122
	123	SYNOPSIS
	124	bfd_boolean bfd_get_full_section_contents
	125	(bfd abfd, asection section, bfd_byte **ptr);
	126
	127	DESCRIPTION
	128	Read all data from @var{section} in BFD @var{abfd}, decompress
	129	if needed, and store in @var{ptr}. If @var{ptr} is NULL,
68ffbac6	130	return @var{*ptr} with memory malloc'd by this function.
4a114e3e L	131
4a114e3e L	132	Return @code{TRUE} if the full section contents is retrieved
06614111 NC	133	successfully. If the section has no contents then this function
06614111 NC	134	returns @code{TRUE} but @var{*ptr} is set to NULL.
4a114e3e L	135	*/
	136
	137	bfd_boolean
	138	bfd_get_full_section_contents (bfd abfd, sec_ptr sec, bfd_byte *ptr)
	139	{
e57278ef	140	bfd_size_type sz;
4a114e3e	141	bfd_byte p = ptr;
82c6068a	142	bfd_boolean ret;
38b774d2 AM	143	bfd_size_type save_size;
38b774d2 AM	144	bfd_size_type save_rawsize;
4a114e3e	145	bfd_byte *compressed_buffer;
4a114e3e	146
e57278ef AM	147	if (abfd->direction != write_direction && sec->rawsize != 0)
	148	sz = sec->rawsize;
	149	else
	150	sz = sec->size;
4a114e3e	151	if (sz == 0)
06614111 NC	152	{
	153	*ptr = NULL;
	154	return TRUE;
	155	}
4a114e3e L	156
	157	switch (sec->compress_status)
	158	{
	159	case COMPRESS_SECTION_NONE:
	160	if (p == NULL)
	161	{
0d13c96b	162	p = (bfd_byte *) bfd_malloc (sz);
4a114e3e L	163	if (p == NULL)
4a114e3e L	164	return FALSE;
4a114e3e	165	}
06614111	166
82c6068a AM	167	if (!bfd_get_section_contents (abfd, sec, p, 0, sz))
	168	{
	169	if (*ptr != p)
	170	free (p);
	171	return FALSE;
	172	}
	173	*ptr = p;
4a114e3e L	174	return TRUE;
	175
	176	case DECOMPRESS_SECTION_SIZED:
82c6068a	177	/* Read in the full compressed section contents. */
38b774d2	178	compressed_buffer = (bfd_byte *) bfd_malloc (sec->compressed_size);
82c6068a AM	179	if (compressed_buffer == NULL)
82c6068a AM	180	return FALSE;
38b774d2 AM	181	save_rawsize = sec->rawsize;
38b774d2 AM	182	save_size = sec->size;
82c6068a AM	183	/* Clear rawsize, set size to compressed size and set compress_status
	184	to COMPRESS_SECTION_NONE. If the compressed size is bigger than
	185	the uncompressed size, bfd_get_section_contents will fail. */
	186	sec->rawsize = 0;
38b774d2	187	sec->size = sec->compressed_size;
82c6068a AM	188	sec->compress_status = COMPRESS_SECTION_NONE;
82c6068a AM	189	ret = bfd_get_section_contents (abfd, sec, compressed_buffer,
38b774d2	190	0, sec->compressed_size);
82c6068a	191	/* Restore rawsize and size. */
38b774d2 AM	192	sec->rawsize = save_rawsize;
38b774d2 AM	193	sec->size = save_size;
4a114e3e	194	sec->compress_status = DECOMPRESS_SECTION_SIZED;
82c6068a AM	195	if (!ret)
82c6068a AM	196	goto fail_compressed;
4a114e3e	197
38b774d2 AM	198	if (p == NULL)
	199	p = (bfd_byte *) bfd_malloc (sz);
	200	if (p == NULL)
4a114e3e	201	goto fail_compressed;
4a114e3e	202
38b774d2	203	if (!decompress_contents (compressed_buffer, sec->compressed_size, p, sz))
82c6068a AM	204	{
82c6068a AM	205	bfd_set_error (bfd_error_bad_value);
38b774d2 AM	206	if (p != *ptr)
38b774d2 AM	207	free (p);
82c6068a AM	208	fail_compressed:
	209	free (compressed_buffer);
	210	return FALSE;
	211	}
4a114e3e	212
82c6068a	213	free (compressed_buffer);
38b774d2 AM	214	*ptr = p;
38b774d2 AM	215	return TRUE;
4a114e3e	216
82c6068a	217	case COMPRESS_SECTION_DONE:
db6b071a NC	218	if (sec->contents == NULL)
db6b071a NC	219	return FALSE;
82c6068a AM	220	if (p == NULL)
	221	{
	222	p = (bfd_byte *) bfd_malloc (sz);
	223	if (p == NULL)
	224	return FALSE;
	225	*ptr = p;
	226	}
06614111 NC	227	/* PR 17512; file: 5bc29788. */
	228	if (p != sec->contents)
	229	memcpy (p, sec->contents, sz);
82c6068a	230	return TRUE;
4a114e3e	231
82c6068a AM	232	default:
	233	abort ();
	234	}
4a114e3e L	235	}
4a114e3e L	236
8a72cc6e AM	237	/*
	238	FUNCTION
	239	bfd_cache_section_contents
	240
	241	SYNOPSIS
	242	void bfd_cache_section_contents
	243	(asection sec, void contents);
	244
	245	DESCRIPTION
	246	Stash @var(contents) so any following reads of @var(sec) do
	247	not need to decompress again.
	248	*/
	249
	250	void
	251	bfd_cache_section_contents (asection sec, void contents)
	252	{
	253	if (sec->compress_status == DECOMPRESS_SECTION_SIZED)
	254	sec->compress_status = COMPRESS_SECTION_DONE;
	255	sec->contents = contents;
	256	sec->flags \|= SEC_IN_MEMORY;
	257	}
	258
	259
4a114e3e L	260	/*
	261	FUNCTION
	262	bfd_is_section_compressed
	263
	264	SYNOPSIS
	265	bfd_boolean bfd_is_section_compressed
	266	(bfd abfd, asection section);
	267
	268	DESCRIPTION
	269	Return @code{TRUE} if @var{section} is compressed.
	270	*/
	271
	272	bfd_boolean
	273	bfd_is_section_compressed (bfd *abfd, sec_ptr sec)
	274	{
	275	bfd_byte compressed_buffer [12];
64f40162 L	276	unsigned int saved = sec->compress_status;
	277	bfd_boolean compressed;
	278
	279	/* Don't decompress the section. */
	280	sec->compress_status = COMPRESS_SECTION_NONE;
4a114e3e L	281
	282	/* Read the zlib header. In this case, it should be "ZLIB" followed
	283	by the uncompressed section size, 8 bytes in big-endian order. */
64f40162 L	284	compressed = (bfd_get_section_contents (abfd, sec, compressed_buffer, 0, 12)
	285	&& CONST_STRNEQ ((char*) compressed_buffer, "ZLIB"));
	286
a953eec9 NC	287	/* Check for the pathalogical case of a debug string section that
	288	contains the string ZLIB.... as the first entry. We assume that
	289	no uncompressed .debug_str section would ever be big enough to
	290	have the first byte of its (big-endian) size be non-zero. */
	291	if (compressed
	292	&& strcmp (sec->name, ".debug_str") == 0
	293	&& ISPRINT (compressed_buffer[4]))
	294	compressed = FALSE;
	295
64f40162 L	296	/* Restore compress_status. */
	297	sec->compress_status = saved;
	298	return compressed;
4a114e3e L	299	}
	300
	301	/*
	302	FUNCTION
	303	bfd_init_section_decompress_status
	304
	305	SYNOPSIS
	306	bfd_boolean bfd_init_section_decompress_status
	307	(bfd abfd, asection section);
	308
	309	DESCRIPTION
	310	Record compressed section size, update section size with
	311	decompressed size and set compress_status to
	312	DECOMPRESS_SECTION_SIZED.
	313
	314	Return @code{FALSE} if the section is not a valid compressed
	315	section or zlib is not installed on this machine. Otherwise,
	316	return @code{TRUE}.
	317	*/
	318
	319	bfd_boolean
243340ad	320	bfd_init_section_decompress_status (bfd *abfd, sec_ptr sec)
4a114e3e	321	{
4a114e3e L	322	bfd_byte compressed_buffer [12];
	323	bfd_size_type uncompressed_size;
	324
	325	if (sec->rawsize != 0
	326	\|\| sec->contents != NULL
	327	\|\| sec->compress_status != COMPRESS_SECTION_NONE
	328	\|\| !bfd_get_section_contents (abfd, sec, compressed_buffer, 0, 12))
	329	{
	330	bfd_set_error (bfd_error_invalid_operation);
	331	return FALSE;
	332	}
1b315056 CS	333
	334	/* Read the zlib header. In this case, it should be "ZLIB" followed
	335	by the uncompressed section size, 8 bytes in big-endian order. */
4a114e3e L	336	if (! CONST_STRNEQ ((char*) compressed_buffer, "ZLIB"))
	337	{
	338	bfd_set_error (bfd_error_wrong_format);
	339	return FALSE;
	340	}
	341
4aa90cc0	342	uncompressed_size = bfd_getb64 (compressed_buffer + 4);
4a114e3e L	343	sec->compressed_size = sec->size;
	344	sec->size = uncompressed_size;
	345	sec->compress_status = DECOMPRESS_SECTION_SIZED;
1b315056	346
4a114e3e	347	return TRUE;
4a114e3e L	348	}
	349
	350	/*
	351	FUNCTION
	352	bfd_init_section_compress_status
	353
	354	SYNOPSIS
	355	bfd_boolean bfd_init_section_compress_status
	356	(bfd abfd, asection section);
	357
	358	DESCRIPTION
	359	If open for read, compress section, update section size with
	360	compressed size and set compress_status to COMPRESS_SECTION_DONE.
	361
	362	Return @code{FALSE} if the section is not a valid compressed
	363	section or zlib is not installed on this machine. Otherwise,
	364	return @code{TRUE}.
	365	*/
	366
	367	bfd_boolean
243340ad	368	bfd_init_section_compress_status (bfd *abfd, sec_ptr sec)
4a114e3e	369	{
4a114e3e L	370	bfd_size_type uncompressed_size;
	371	bfd_byte *uncompressed_buffer;
	372	bfd_boolean ret;
	373
	374	/* Error if not opened for read. */
	375	if (abfd->direction != read_direction
	376	\|\| sec->size == 0
	377	\|\| sec->rawsize != 0
	378	\|\| sec->contents != NULL
	379	\|\| sec->compress_status != COMPRESS_SECTION_NONE)
1b315056	380	{
4a114e3e L	381	bfd_set_error (bfd_error_invalid_operation);
4a114e3e L	382	return FALSE;
1b315056	383	}
1b315056	384
4a114e3e L	385	/* Read in the full section contents and compress it. */
	386	uncompressed_size = sec->size;
	387	uncompressed_buffer = (bfd_byte *) bfd_malloc (uncompressed_size);
	388	if (!bfd_get_section_contents (abfd, sec, uncompressed_buffer,
	389	0, uncompressed_size))
	390	ret = FALSE;
	391	else
	392	ret = bfd_compress_section_contents (abfd, sec,
	393	uncompressed_buffer,
	394	uncompressed_size);
1b315056	395
4a114e3e	396	return ret;
1b315056	397	}