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

/* Compressed section support (intended for debug sections).
   Copyright (C) 2008-2014 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
#include "safe-ctype.h"

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

  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;
}
#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 save_size;
  bfd_size_type save_rawsize;
  bfd_byte *compressed_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.  */
      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;
#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_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 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).
4b95cf5c	2	Copyright (C) 2008-2014 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 CS	21	#include "sysdep.h"
	22	#include "bfd.h"
	23	#include "libbfd.h"
	24	#ifdef HAVE_ZLIB_H
	25	#include <zlib.h>
	26	#endif
a953eec9	27	#include "safe-ctype.h"
1b315056	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
a253d456	48	BFD_ASSERT (Z_OK == 0);
4a114e3e	49	rc = inflateInit (&strm);
a29a8af8	50	while (strm.avail_in > 0 && strm.avail_out > 0)
4a114e3e L	51	{
4a114e3e L	52	if (rc != Z_OK)
a253d456	53	break;
4a114e3e L	54	strm.next_out = ((Bytef*) uncompressed_buffer
	55	+ (uncompressed_size - strm.avail_out));
	56	rc = inflate (&strm, Z_FINISH);
	57	if (rc != Z_STREAM_END)
a253d456	58	break;
4a114e3e L	59	rc = inflateReset (&strm);
4a114e3e L	60	}
a253d456	61	rc \|= inflateEnd (&strm);
82c6068a	62	return rc == Z_OK && strm.avail_out == 0;
4a114e3e L	63	}
	64	#endif
	65
1b315056 CS	66	/*
1b315056 CS	67	FUNCTION
4a114e3e	68	bfd_compress_section_contents
1b315056 CS	69
1b315056 CS	70	SYNOPSIS
4a114e3e L	71	bfd_boolean bfd_compress_section_contents
	72	(bfd abfd, asection section, bfd_byte *uncompressed_buffer,
	73	bfd_size_type uncompressed_size);
1b315056 CS	74
	75	DESCRIPTION
	76
4a114e3e L	77	Compress data of the size specified in @var{uncompressed_size}
	78	and pointed to by @var{uncompressed_buffer} using zlib and store
	79	as the contents field. This function assumes the contents
	80	field was allocated using bfd_malloc() or equivalent. If zlib
	81	is not installed on this machine, the input is unmodified.
	82
68ffbac6	83	Return @code{TRUE} if the full section contents is compressed
4a114e3e	84	successfully.
1b315056 CS	85	*/
	86
	87	bfd_boolean
4a114e3e L	88	bfd_compress_section_contents (bfd *abfd ATTRIBUTE_UNUSED,
	89	sec_ptr sec ATTRIBUTE_UNUSED,
	90	bfd_byte *uncompressed_buffer ATTRIBUTE_UNUSED,
	91	bfd_size_type uncompressed_size ATTRIBUTE_UNUSED)
1b315056 CS	92	{
1b315056 CS	93	#ifndef HAVE_ZLIB_H
4a114e3e	94	bfd_set_error (bfd_error_invalid_operation);
1b315056 CS	95	return FALSE;
1b315056 CS	96	#else
ae6a0217	97	uLong compressed_size;
4a114e3e L	98	bfd_byte *compressed_buffer;
	99
	100	compressed_size = compressBound (uncompressed_size) + 12;
	101	compressed_buffer = (bfd_byte *) bfd_malloc (compressed_size);
	102
4281caad MS	103	if (compressed_buffer == NULL)
	104	return FALSE;
	105
4a114e3e L	106	if (compress ((Bytef*) compressed_buffer + 12,
	107	&compressed_size,
	108	(const Bytef*) uncompressed_buffer,
	109	uncompressed_size) != Z_OK)
	110	{
	111	free (compressed_buffer);
	112	bfd_set_error (bfd_error_bad_value);
	113	return FALSE;
	114	}
	115
	116	/* Write the zlib header. In this case, it should be "ZLIB" followed
	117	by the uncompressed section size, 8 bytes in big-endian order. */
	118	memcpy (compressed_buffer, "ZLIB", 4);
	119	compressed_buffer[11] = uncompressed_size; uncompressed_size >>= 8;
	120	compressed_buffer[10] = uncompressed_size; uncompressed_size >>= 8;
	121	compressed_buffer[9] = uncompressed_size; uncompressed_size >>= 8;
	122	compressed_buffer[8] = uncompressed_size; uncompressed_size >>= 8;
	123	compressed_buffer[7] = uncompressed_size; uncompressed_size >>= 8;
	124	compressed_buffer[6] = uncompressed_size; uncompressed_size >>= 8;
	125	compressed_buffer[5] = uncompressed_size; uncompressed_size >>= 8;
	126	compressed_buffer[4] = uncompressed_size;
	127	compressed_size += 12;
	128
	129	/* Free the uncompressed contents if we compress in place. */
	130	if (uncompressed_buffer == sec->contents)
	131	free (uncompressed_buffer);
	132
	133	sec->contents = compressed_buffer;
	134	sec->size = compressed_size;
	135	sec->compress_status = COMPRESS_SECTION_DONE;
	136
	137	return TRUE;
	138	#endif /* HAVE_ZLIB_H */
	139	}
	140
	141	/*
	142	FUNCTION
	143	bfd_get_full_section_contents
	144
	145	SYNOPSIS
	146	bfd_boolean bfd_get_full_section_contents
	147	(bfd abfd, asection section, bfd_byte **ptr);
	148
	149	DESCRIPTION
	150	Read all data from @var{section} in BFD @var{abfd}, decompress
	151	if needed, and store in @var{ptr}. If @var{ptr} is NULL,
68ffbac6	152	return @var{*ptr} with memory malloc'd by this function.
4a114e3e L	153
	154	Return @code{TRUE} if the full section contents is retrieved
	155	successfully.
	156	*/
	157
	158	bfd_boolean
	159	bfd_get_full_section_contents (bfd abfd, sec_ptr sec, bfd_byte *ptr)
	160	{
e57278ef	161	bfd_size_type sz;
4a114e3e	162	bfd_byte p = ptr;
4a114e3e	163	#ifdef HAVE_ZLIB_H
82c6068a	164	bfd_boolean ret;
38b774d2 AM	165	bfd_size_type save_size;
38b774d2 AM	166	bfd_size_type save_rawsize;
4a114e3e	167	bfd_byte *compressed_buffer;
4a114e3e L	168	#endif
4a114e3e L	169
e57278ef AM	170	if (abfd->direction != write_direction && sec->rawsize != 0)
	171	sz = sec->rawsize;
	172	else
	173	sz = sec->size;
4a114e3e L	174	if (sz == 0)
	175	return TRUE;
	176
	177	switch (sec->compress_status)
	178	{
	179	case COMPRESS_SECTION_NONE:
	180	if (p == NULL)
	181	{
0d13c96b	182	p = (bfd_byte *) bfd_malloc (sz);
4a114e3e L	183	if (p == NULL)
4a114e3e L	184	return FALSE;
4a114e3e	185	}
82c6068a AM	186	if (!bfd_get_section_contents (abfd, sec, p, 0, sz))
	187	{
	188	if (*ptr != p)
	189	free (p);
	190	return FALSE;
	191	}
	192	*ptr = p;
4a114e3e L	193	return TRUE;
	194
	195	case DECOMPRESS_SECTION_SIZED:
4a114e3e	196	#ifndef HAVE_ZLIB_H
82c6068a AM	197	bfd_set_error (bfd_error_invalid_operation);
82c6068a AM	198	return FALSE;
4a114e3e	199	#else
82c6068a	200	/* Read in the full compressed section contents. */
38b774d2	201	compressed_buffer = (bfd_byte *) bfd_malloc (sec->compressed_size);
82c6068a AM	202	if (compressed_buffer == NULL)
82c6068a AM	203	return FALSE;
38b774d2 AM	204	save_rawsize = sec->rawsize;
38b774d2 AM	205	save_size = sec->size;
82c6068a AM	206	/* Clear rawsize, set size to compressed size and set compress_status
	207	to COMPRESS_SECTION_NONE. If the compressed size is bigger than
	208	the uncompressed size, bfd_get_section_contents will fail. */
	209	sec->rawsize = 0;
38b774d2	210	sec->size = sec->compressed_size;
82c6068a AM	211	sec->compress_status = COMPRESS_SECTION_NONE;
82c6068a AM	212	ret = bfd_get_section_contents (abfd, sec, compressed_buffer,
38b774d2	213	0, sec->compressed_size);
82c6068a	214	/* Restore rawsize and size. */
38b774d2 AM	215	sec->rawsize = save_rawsize;
38b774d2 AM	216	sec->size = save_size;
4a114e3e	217	sec->compress_status = DECOMPRESS_SECTION_SIZED;
82c6068a AM	218	if (!ret)
82c6068a AM	219	goto fail_compressed;
4a114e3e	220
38b774d2 AM	221	if (p == NULL)
	222	p = (bfd_byte *) bfd_malloc (sz);
	223	if (p == NULL)
4a114e3e	224	goto fail_compressed;
4a114e3e	225
38b774d2	226	if (!decompress_contents (compressed_buffer, sec->compressed_size, p, sz))
82c6068a AM	227	{
82c6068a AM	228	bfd_set_error (bfd_error_bad_value);
38b774d2 AM	229	if (p != *ptr)
38b774d2 AM	230	free (p);
82c6068a AM	231	fail_compressed:
	232	free (compressed_buffer);
	233	return FALSE;
	234	}
4a114e3e	235
82c6068a	236	free (compressed_buffer);
38b774d2 AM	237	*ptr = p;
38b774d2 AM	238	return TRUE;
82c6068a	239	#endif
4a114e3e	240
82c6068a AM	241	case COMPRESS_SECTION_DONE:
	242	if (p == NULL)
	243	{
	244	p = (bfd_byte *) bfd_malloc (sz);
	245	if (p == NULL)
	246	return FALSE;
	247	*ptr = p;
	248	}
	249	memcpy (p, sec->contents, sz);
	250	return TRUE;
4a114e3e	251
82c6068a AM	252	default:
	253	abort ();
	254	}
4a114e3e L	255	}
4a114e3e L	256
8a72cc6e AM	257	/*
	258	FUNCTION
	259	bfd_cache_section_contents
	260
	261	SYNOPSIS
	262	void bfd_cache_section_contents
	263	(asection sec, void contents);
	264
	265	DESCRIPTION
	266	Stash @var(contents) so any following reads of @var(sec) do
	267	not need to decompress again.
	268	*/
	269
	270	void
	271	bfd_cache_section_contents (asection sec, void contents)
	272	{
	273	if (sec->compress_status == DECOMPRESS_SECTION_SIZED)
	274	sec->compress_status = COMPRESS_SECTION_DONE;
	275	sec->contents = contents;
	276	sec->flags \|= SEC_IN_MEMORY;
	277	}
	278
	279
4a114e3e L	280	/*
	281	FUNCTION
	282	bfd_is_section_compressed
	283
	284	SYNOPSIS
	285	bfd_boolean bfd_is_section_compressed
	286	(bfd abfd, asection section);
	287
	288	DESCRIPTION
	289	Return @code{TRUE} if @var{section} is compressed.
	290	*/
	291
	292	bfd_boolean
	293	bfd_is_section_compressed (bfd *abfd, sec_ptr sec)
	294	{
	295	bfd_byte compressed_buffer [12];
64f40162 L	296	unsigned int saved = sec->compress_status;
	297	bfd_boolean compressed;
	298
	299	/* Don't decompress the section. */
	300	sec->compress_status = COMPRESS_SECTION_NONE;
4a114e3e L	301
	302	/* Read the zlib header. In this case, it should be "ZLIB" followed
	303	by the uncompressed section size, 8 bytes in big-endian order. */
64f40162 L	304	compressed = (bfd_get_section_contents (abfd, sec, compressed_buffer, 0, 12)
	305	&& CONST_STRNEQ ((char*) compressed_buffer, "ZLIB"));
	306
a953eec9 NC	307	/* Check for the pathalogical case of a debug string section that
	308	contains the string ZLIB.... as the first entry. We assume that
	309	no uncompressed .debug_str section would ever be big enough to
	310	have the first byte of its (big-endian) size be non-zero. */
	311	if (compressed
	312	&& strcmp (sec->name, ".debug_str") == 0
	313	&& ISPRINT (compressed_buffer[4]))
	314	compressed = FALSE;
	315
64f40162 L	316	/* Restore compress_status. */
	317	sec->compress_status = saved;
	318	return compressed;
4a114e3e L	319	}
	320
	321	/*
	322	FUNCTION
	323	bfd_init_section_decompress_status
	324
	325	SYNOPSIS
	326	bfd_boolean bfd_init_section_decompress_status
	327	(bfd abfd, asection section);
	328
	329	DESCRIPTION
	330	Record compressed section size, update section size with
	331	decompressed size and set compress_status to
	332	DECOMPRESS_SECTION_SIZED.
	333
	334	Return @code{FALSE} if the section is not a valid compressed
	335	section or zlib is not installed on this machine. Otherwise,
	336	return @code{TRUE}.
	337	*/
	338
	339	bfd_boolean
	340	bfd_init_section_decompress_status (bfd *abfd ATTRIBUTE_UNUSED,
	341	sec_ptr sec ATTRIBUTE_UNUSED)
	342	{
	343	#ifndef HAVE_ZLIB_H
	344	bfd_set_error (bfd_error_invalid_operation);
	345	return FALSE;
	346	#else
	347	bfd_byte compressed_buffer [12];
	348	bfd_size_type uncompressed_size;
	349
	350	if (sec->rawsize != 0
	351	\|\| sec->contents != NULL
	352	\|\| sec->compress_status != COMPRESS_SECTION_NONE
	353	\|\| !bfd_get_section_contents (abfd, sec, compressed_buffer, 0, 12))
	354	{
	355	bfd_set_error (bfd_error_invalid_operation);
	356	return FALSE;
	357	}
1b315056 CS	358
	359	/* Read the zlib header. In this case, it should be "ZLIB" followed
	360	by the uncompressed section size, 8 bytes in big-endian order. */
4a114e3e L	361	if (! CONST_STRNEQ ((char*) compressed_buffer, "ZLIB"))
	362	{
	363	bfd_set_error (bfd_error_wrong_format);
	364	return FALSE;
	365	}
	366
1b315056 CS	367	uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
	368	uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
	369	uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
	370	uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
	371	uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
	372	uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
	373	uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
	374	uncompressed_size += compressed_buffer[11];
	375
4a114e3e L	376	sec->compressed_size = sec->size;
	377	sec->size = uncompressed_size;
	378	sec->compress_status = DECOMPRESS_SECTION_SIZED;
1b315056	379
4a114e3e L	380	return TRUE;
	381	#endif
	382	}
	383
	384	/*
	385	FUNCTION
	386	bfd_init_section_compress_status
	387
	388	SYNOPSIS
	389	bfd_boolean bfd_init_section_compress_status
	390	(bfd abfd, asection section);
	391
	392	DESCRIPTION
	393	If open for read, compress section, update section size with
	394	compressed size and set compress_status to COMPRESS_SECTION_DONE.
	395
	396	Return @code{FALSE} if the section is not a valid compressed
	397	section or zlib is not installed on this machine. Otherwise,
	398	return @code{TRUE}.
	399	*/
	400
	401	bfd_boolean
	402	bfd_init_section_compress_status (bfd *abfd ATTRIBUTE_UNUSED,
	403	sec_ptr sec ATTRIBUTE_UNUSED)
	404	{
	405	#ifndef HAVE_ZLIB_H
	406	bfd_set_error (bfd_error_invalid_operation);
	407	return FALSE;
	408	#else
	409	bfd_size_type uncompressed_size;
	410	bfd_byte *uncompressed_buffer;
	411	bfd_boolean ret;
	412
	413	/* Error if not opened for read. */
	414	if (abfd->direction != read_direction
	415	\|\| sec->size == 0
	416	\|\| sec->rawsize != 0
	417	\|\| sec->contents != NULL
	418	\|\| sec->compress_status != COMPRESS_SECTION_NONE)
1b315056	419	{
4a114e3e L	420	bfd_set_error (bfd_error_invalid_operation);
4a114e3e L	421	return FALSE;
1b315056	422	}
1b315056	423
4a114e3e L	424	/* Read in the full section contents and compress it. */
	425	uncompressed_size = sec->size;
	426	uncompressed_buffer = (bfd_byte *) bfd_malloc (uncompressed_size);
	427	if (!bfd_get_section_contents (abfd, sec, uncompressed_buffer,
	428	0, uncompressed_size))
	429	ret = FALSE;
	430	else
	431	ret = bfd_compress_section_contents (abfd, sec,
	432	uncompressed_buffer,
	433	uncompressed_size);
1b315056	434
1b315056	435	free (uncompressed_buffer);
4a114e3e L	436	return ret;
4a114e3e L	437	#endif
1b315056	438	}