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

/* Compressed section support (intended for debug sections).
   Copyright 2008, 2010, 2011, 2012
   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 "bfd.h"
#include "libbfd.h"
#ifdef HAVE_ZLIB_H
#include <zlib.h>
#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;
}
#endif

/*
FUNCTION
	bfd_compress_section_contents

SYNOPSIS
	bfd_boolean bfd_compress_section_contents
	  (bfd *abfd, asection *section, bfd_byte *uncompressed_buffer,
	   bfd_size_type uncompressed_size);

DESCRIPTION

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

  /* 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;
  bfd_byte *p = *ptr;
#ifdef HAVE_ZLIB_H
  bfd_boolean ret;
  bfd_size_type compressed_size;
  bfd_size_type uncompressed_size;
  bfd_size_type rawsize;
  bfd_byte *compressed_buffer;
  bfd_byte *uncompressed_buffer;
#endif

  if (abfd->direction != write_direction && sec->rawsize != 0)
    sz = sec->rawsize;
  else
    sz = sec->size;
  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;
	}
      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:
#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);
      if (compressed_buffer == NULL)
	return FALSE;
      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;
      sec->compress_status = DECOMPRESS_SECTION_SIZED;
      if (!ret)
	goto fail_compressed;

      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))
	{
	  bfd_set_error (bfd_error_bad_value);
	  free (uncompressed_buffer);
	fail_compressed:
	  free (compressed_buffer);
	  return FALSE;
	}

      free (compressed_buffer);
      sec->contents = uncompressed_buffer;
      sec->compress_status = COMPRESS_SECTION_DONE;
      /* Fall thru */
#endif

    case COMPRESS_SECTION_DONE:
      if (p == NULL)
	{
	  p = (bfd_byte *) bfd_malloc (sz);
	  if (p == NULL)
	    return FALSE;
	  *ptr = p;
	}
      memcpy (p, sec->contents, sz);
      return TRUE;

    default:
      abort ();
    }
}

/*
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 (! 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;
  uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
  uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
  uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
  uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
  uncompressed_size += compressed_buffer[11];

  sec->compressed_size = sec->size;
  sec->size = uncompressed_size;
  sec->compress_status = DECOMPRESS_SECTION_SIZED;

  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)
    {
      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);

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