[thirdparty/gcc.git] / gcc / lto-compress.c

/* LTO IL compression streams.

   Copyright (C) 2009-2020 Free Software Foundation, Inc.
   Contributed by Simon Baldwin <simonb@google.com>

This file is part of GCC.

GCC 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, or (at your option)
any later version.

GCC 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 GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "backend.h"
#include "tree.h"
#include "gimple.h"
#include "cgraph.h"
#include "lto-streamer.h"
/* zlib.h includes other system headers.  Those headers may test feature
   test macros.  config.h may define feature test macros.  For this reason,
   zlib.h needs to be included after, rather than before, config.h and
   system.h.  */
#include <zlib.h>
#include "lto-compress.h"
#include "timevar.h"

#ifdef HAVE_ZSTD_H
#include <zstd.h>
#endif

/* Compression stream structure, holds the flush callback and opaque token,
   the buffered data, and a note of whether compressing or uncompressing.  */

struct lto_compression_stream
{
  void (*callback) (const char *, unsigned, void *);
  void *opaque;
  char *buffer;
  size_t bytes;
  size_t allocation;
  bool is_compression;
};

/* Overall compression constants for zlib.  */

static const size_t Z_BUFFER_LENGTH = 4096;
static const size_t MIN_STREAM_ALLOCATION = 1024;

/* For zlib, allocate SIZE count of ITEMS and return the address, OPAQUE
   is unused.  */

static void *
lto_zalloc (void *opaque, unsigned items, unsigned size)
{
  gcc_assert (opaque == Z_NULL);
  return xmalloc (items * size);
}

/* For zlib, free memory at ADDRESS, OPAQUE is unused.  */

static void
lto_zfree (void *opaque, void *address)
{
  gcc_assert (opaque == Z_NULL);
  free (address);
}

/* Return a zlib compression level that zlib will not reject.  Normalizes
   the compression level from the command line flag, clamping non-default
   values to the appropriate end of their valid range.  */

static int
lto_normalized_zlib_level (void)
{
  int level = flag_lto_compression_level;

  if (level != Z_DEFAULT_COMPRESSION)
    {
      if (level < Z_NO_COMPRESSION)
	level = Z_NO_COMPRESSION;
      else if (level > Z_BEST_COMPRESSION)
	level = Z_BEST_COMPRESSION;
    }

  return level;
}

/* Free the buffer and memory associated with STREAM.  */

static void
lto_destroy_compression_stream (struct lto_compression_stream *stream)
{
  free (stream->buffer);
  free (stream);
}

#ifdef HAVE_ZSTD_H
/* Return a zstd compression level that zstd will not reject.  Normalizes
   the compression level from the command line flag, clamping non-default
   values to the appropriate end of their valid range.  */

static int
lto_normalized_zstd_level (void)
{
  int level = flag_lto_compression_level;

  if (level < 0)
    level = 0;
  else if (level > ZSTD_maxCLevel ())
    level = ZSTD_maxCLevel ();

  return level;
}

/* Compress STREAM using ZSTD algorithm.  */

static void
lto_compression_zstd (struct lto_compression_stream *stream)
{
  unsigned char *cursor = (unsigned char *) stream->buffer;
  size_t size = stream->bytes;

  timevar_push (TV_IPA_LTO_COMPRESS);
  size_t const outbuf_length = ZSTD_compressBound (size);
  char *outbuf = (char *) xmalloc (outbuf_length);

  size_t const csize = ZSTD_compress (outbuf, outbuf_length, cursor, size,
				      lto_normalized_zstd_level ());

  if (ZSTD_isError (csize))
    internal_error ("compressed stream: %s", ZSTD_getErrorName (csize));

  stream->callback (outbuf, csize, NULL);

  lto_destroy_compression_stream (stream);
  free (outbuf);
  timevar_pop (TV_IPA_LTO_COMPRESS);
}

/* Uncompress STREAM using ZSTD algorithm.  */

static void
lto_uncompression_zstd (struct lto_compression_stream *stream)
{
  unsigned char *cursor = (unsigned char *) stream->buffer;
  size_t size = stream->bytes;

  timevar_push (TV_IPA_LTO_DECOMPRESS);
  unsigned long long const rsize = ZSTD_getFrameContentSize (cursor, size);
  if (rsize == ZSTD_CONTENTSIZE_ERROR)
    internal_error ("original not compressed with zstd");
  else if (rsize == ZSTD_CONTENTSIZE_UNKNOWN)
    internal_error ("original size unknown");

  char *outbuf = (char *) xmalloc (rsize);
  size_t const dsize = ZSTD_decompress (outbuf, rsize, cursor, size);

  if (ZSTD_isError (dsize))
    internal_error ("decompressed stream: %s", ZSTD_getErrorName (dsize));

  stream->callback (outbuf, dsize, stream->opaque);

  lto_destroy_compression_stream (stream);
  free (outbuf);
  timevar_pop (TV_IPA_LTO_DECOMPRESS);
}

#endif

/* Create a new compression stream, with CALLBACK flush function passed
   OPAQUE token, IS_COMPRESSION indicates if compressing or uncompressing.  */

static struct lto_compression_stream *
lto_new_compression_stream (void (*callback) (const char *, unsigned, void *),
			    void *opaque, bool is_compression)
{
  struct lto_compression_stream *stream
    = (struct lto_compression_stream *) xmalloc (sizeof (*stream));

  memset (stream, 0, sizeof (*stream));
  stream->callback = callback;
  stream->opaque = opaque;
  stream->is_compression = is_compression;

  return stream;
}

/* Append NUM_CHARS from address BASE to STREAM.  */

static void
lto_append_to_compression_stream (struct lto_compression_stream *stream,
				  const char *base, size_t num_chars)
{
  size_t required = stream->bytes + num_chars;

  if (stream->allocation < required)
    {
      if (stream->allocation == 0)
	stream->allocation = MIN_STREAM_ALLOCATION;
      while (stream->allocation < required)
	stream->allocation *= 2;

      stream->buffer = (char *) xrealloc (stream->buffer, stream->allocation);
    }

  memcpy (stream->buffer + stream->bytes, base, num_chars);
  stream->bytes += num_chars;
}

/* Return a new compression stream, with CALLBACK flush function passed
   OPAQUE token.  */

struct lto_compression_stream *
lto_start_compression (void (*callback) (const char *, unsigned, void *),
		       void *opaque)
{
  return lto_new_compression_stream (callback, opaque, true);
}

/* Append NUM_CHARS from address BASE to STREAM.  */

void
lto_compress_block (struct lto_compression_stream *stream,
		    const char *base, size_t num_chars)
{
  gcc_assert (stream->is_compression);

  lto_append_to_compression_stream (stream, base, num_chars);
  lto_stats.num_output_il_bytes += num_chars;
}

static void ATTRIBUTE_UNUSED
lto_compression_zlib (struct lto_compression_stream *stream)
{
  unsigned char *cursor = (unsigned char *) stream->buffer;
  size_t remaining = stream->bytes;
  const size_t outbuf_length = Z_BUFFER_LENGTH;
  unsigned char *outbuf = (unsigned char *) xmalloc (outbuf_length);
  z_stream out_stream;
  size_t compressed_bytes = 0;
  int status;

  gcc_assert (stream->is_compression);

  timevar_push (TV_IPA_LTO_COMPRESS);

  out_stream.next_out = outbuf;
  out_stream.avail_out = outbuf_length;
  out_stream.next_in = cursor;
  out_stream.avail_in = remaining;
  out_stream.zalloc = lto_zalloc;
  out_stream.zfree = lto_zfree;
  out_stream.opaque = Z_NULL;

  status = deflateInit (&out_stream, lto_normalized_zlib_level ());
  if (status != Z_OK)
    internal_error ("compressed stream: %s", zError (status));

  do
    {
      size_t in_bytes, out_bytes;

      status = deflate (&out_stream, Z_FINISH);
      if (status != Z_OK && status != Z_STREAM_END)
	internal_error ("compressed stream: %s", zError (status));

      in_bytes = remaining - out_stream.avail_in;
      out_bytes = outbuf_length - out_stream.avail_out;

      stream->callback ((const char *) outbuf, out_bytes, stream->opaque);
      lto_stats.num_compressed_il_bytes += out_bytes;
      compressed_bytes += out_bytes;

      cursor += in_bytes;
      remaining -= in_bytes;

      out_stream.next_out = outbuf;
      out_stream.avail_out = outbuf_length;
      out_stream.next_in = cursor;
      out_stream.avail_in = remaining;
    }
  while (status != Z_STREAM_END);

  status = deflateEnd (&out_stream);
  if (status != Z_OK)
    internal_error ("compressed stream: %s", zError (status));

  lto_destroy_compression_stream (stream);
  free (outbuf);
  timevar_pop (TV_IPA_LTO_COMPRESS);
}

void
lto_end_compression (struct lto_compression_stream *stream)
{
#ifdef HAVE_ZSTD_H
  lto_compression_zstd (stream);
#else
  lto_compression_zlib (stream);
#endif
}

/* Return a new uncompression stream, with CALLBACK flush function passed
   OPAQUE token.  */

struct lto_compression_stream *
lto_start_uncompression (void (*callback) (const char *, unsigned, void *),
			 void *opaque)
{
  return lto_new_compression_stream (callback, opaque, false);
}

/* Append NUM_CHARS from address BASE to STREAM.  */

void
lto_uncompress_block (struct lto_compression_stream *stream,
		      const char *base, size_t num_chars)
{
  gcc_assert (!stream->is_compression);

  lto_append_to_compression_stream (stream, base, num_chars);
  lto_stats.num_input_il_bytes += num_chars;
}

static void
lto_uncompression_zlib (struct lto_compression_stream *stream)
{
  unsigned char *cursor = (unsigned char *) stream->buffer;
  size_t remaining = stream->bytes;
  const size_t outbuf_length = Z_BUFFER_LENGTH;
  unsigned char *outbuf = (unsigned char *) xmalloc (outbuf_length);
  size_t uncompressed_bytes = 0;

  gcc_assert (!stream->is_compression);
  timevar_push (TV_IPA_LTO_DECOMPRESS);

  while (remaining > 0)
    {
      z_stream in_stream;
      size_t out_bytes;
      int status;

      in_stream.next_out = outbuf;
      in_stream.avail_out = outbuf_length;
      in_stream.next_in = cursor;
      in_stream.avail_in = remaining;
      in_stream.zalloc = lto_zalloc;
      in_stream.zfree = lto_zfree;
      in_stream.opaque = Z_NULL;

      status = inflateInit (&in_stream);
      if (status != Z_OK)
	internal_error ("compressed stream: %s", zError (status));

      do
	{
	  size_t in_bytes;

	  status = inflate (&in_stream, Z_SYNC_FLUSH);
	  if (status != Z_OK && status != Z_STREAM_END)
	    internal_error ("compressed stream: %s", zError (status));

	  in_bytes = remaining - in_stream.avail_in;
	  out_bytes = outbuf_length - in_stream.avail_out;

	  stream->callback ((const char *) outbuf, out_bytes, stream->opaque);
	  lto_stats.num_uncompressed_il_bytes += out_bytes;
	  uncompressed_bytes += out_bytes;

	  cursor += in_bytes;
	  remaining -= in_bytes;

	  in_stream.next_out = outbuf;
	  in_stream.avail_out = outbuf_length;
	  in_stream.next_in = cursor;
	  in_stream.avail_in = remaining;
	}
      while (!(status == Z_STREAM_END && out_bytes == 0));

      status = inflateEnd (&in_stream);
      if (status != Z_OK)
	internal_error ("compressed stream: %s", zError (status));
    }

  lto_destroy_compression_stream (stream);
  free (outbuf);
  timevar_pop (TV_IPA_LTO_DECOMPRESS);
}

void
lto_end_uncompression (struct lto_compression_stream *stream,
		       lto_compression compression)
{
#ifdef HAVE_ZSTD_H
  if (compression == ZSTD)
    {
      lto_uncompression_zstd (stream);
      return;
    }
#endif
  if (compression == ZSTD)
    internal_error ("compiler does not support ZSTD LTO compression");

  lto_uncompression_zlib (stream);
}
Commit	Line	Data
d7f09764 DN	1	/* LTO IL compression streams.
d7f09764 DN	2
8d9254fc	3	Copyright (C) 2009-2020 Free Software Foundation, Inc.
d7f09764 DN	4	Contributed by Simon Baldwin <simonb@google.com>
	5
	6	This file is part of GCC.
	7
	8	GCC is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 3, or (at your option)
	11	any later version.
	12
	13	GCC is distributed in the hope that it will be useful, but WITHOUT
	14	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
	15	or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
	16	License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with GCC; see the file COPYING3. If not see
	20	<http://www.gnu.org/licenses/>. */
	21
	22	#include "config.h"
	23	#include "system.h"
957060b5 AM	24	#include "coretypes.h"
957060b5 AM	25	#include "backend.h"
957060b5 AM	26	#include "tree.h"
	27	#include "gimple.h"
	28	#include "cgraph.h"
	29	#include "lto-streamer.h"
d7f09764 DN	30	/* zlib.h includes other system headers. Those headers may test feature
	31	test macros. config.h may define feature test macros. For this reason,
	32	zlib.h needs to be included after, rather than before, config.h and
	33	system.h. */
	34	#include <zlib.h>
d7f09764	35	#include "lto-compress.h"
ed7dc894	36	#include "timevar.h"
d7f09764	37
87741e51 ML	38	#ifdef HAVE_ZSTD_H
	39	#include <zstd.h>
	40	#endif
	41
d7f09764 DN	42	/* Compression stream structure, holds the flush callback and opaque token,
	43	the buffered data, and a note of whether compressing or uncompressing. */
	44
	45	struct lto_compression_stream
	46	{
	47	void (callback) (const char , unsigned, void *);
	48	void *opaque;
	49	char *buffer;
	50	size_t bytes;
	51	size_t allocation;
	52	bool is_compression;
	53	};
	54
	55	/* Overall compression constants for zlib. */
	56
	57	static const size_t Z_BUFFER_LENGTH = 4096;
	58	static const size_t MIN_STREAM_ALLOCATION = 1024;
	59
	60	/* For zlib, allocate SIZE count of ITEMS and return the address, OPAQUE
	61	is unused. */
	62
	63	static void *
	64	lto_zalloc (void *opaque, unsigned items, unsigned size)
	65	{
	66	gcc_assert (opaque == Z_NULL);
	67	return xmalloc (items * size);
	68	}
	69
	70	/* For zlib, free memory at ADDRESS, OPAQUE is unused. */
	71
	72	static void
	73	lto_zfree (void opaque, void address)
	74	{
	75	gcc_assert (opaque == Z_NULL);
	76	free (address);
	77	}
	78
	79	/* Return a zlib compression level that zlib will not reject. Normalizes
	80	the compression level from the command line flag, clamping non-default
	81	values to the appropriate end of their valid range. */
	82
	83	static int
	84	lto_normalized_zlib_level (void)
	85	{
	86	int level = flag_lto_compression_level;
	87
	88	if (level != Z_DEFAULT_COMPRESSION)
	89	{
	90	if (level < Z_NO_COMPRESSION)
	91	level = Z_NO_COMPRESSION;
	92	else if (level > Z_BEST_COMPRESSION)
	93	level = Z_BEST_COMPRESSION;
	94	}
	95
	96	return level;
	97	}
	98
87741e51 ML	99	/* Free the buffer and memory associated with STREAM. */
	100
	101	static void
	102	lto_destroy_compression_stream (struct lto_compression_stream *stream)
	103	{
	104	free (stream->buffer);
	105	free (stream);
	106	}
	107
	108	#ifdef HAVE_ZSTD_H
	109	/* Return a zstd compression level that zstd will not reject. Normalizes
	110	the compression level from the command line flag, clamping non-default
	111	values to the appropriate end of their valid range. */
	112
	113	static int
	114	lto_normalized_zstd_level (void)
	115	{
	116	int level = flag_lto_compression_level;
	117
7a26ff04 ML	118	if (level < 0)
	119	level = 0;
	120	else if (level > ZSTD_maxCLevel ())
	121	level = ZSTD_maxCLevel ();
87741e51 ML	122
	123	return level;
	124	}
	125
	126	/* Compress STREAM using ZSTD algorithm. */
	127
	128	static void
	129	lto_compression_zstd (struct lto_compression_stream *stream)
	130	{
	131	unsigned char cursor = (unsigned char ) stream->buffer;
	132	size_t size = stream->bytes;
	133
	134	timevar_push (TV_IPA_LTO_COMPRESS);
	135	size_t const outbuf_length = ZSTD_compressBound (size);
	136	char outbuf = (char ) xmalloc (outbuf_length);
	137
	138	size_t const csize = ZSTD_compress (outbuf, outbuf_length, cursor, size,
	139	lto_normalized_zstd_level ());
	140
	141	if (ZSTD_isError (csize))
	142	internal_error ("compressed stream: %s", ZSTD_getErrorName (csize));
	143
	144	stream->callback (outbuf, csize, NULL);
	145
	146	lto_destroy_compression_stream (stream);
	147	free (outbuf);
	148	timevar_pop (TV_IPA_LTO_COMPRESS);
	149	}
	150
	151	/* Uncompress STREAM using ZSTD algorithm. */
	152
	153	static void
	154	lto_uncompression_zstd (struct lto_compression_stream *stream)
	155	{
	156	unsigned char cursor = (unsigned char ) stream->buffer;
	157	size_t size = stream->bytes;
	158
	159	timevar_push (TV_IPA_LTO_DECOMPRESS);
	160	unsigned long long const rsize = ZSTD_getFrameContentSize (cursor, size);
	161	if (rsize == ZSTD_CONTENTSIZE_ERROR)
	162	internal_error ("original not compressed with zstd");
	163	else if (rsize == ZSTD_CONTENTSIZE_UNKNOWN)
	164	internal_error ("original size unknown");
	165
	166	char outbuf = (char ) xmalloc (rsize);
	167	size_t const dsize = ZSTD_decompress (outbuf, rsize, cursor, size);
	168
	169	if (ZSTD_isError (dsize))
	170	internal_error ("decompressed stream: %s", ZSTD_getErrorName (dsize));
	171
	172	stream->callback (outbuf, dsize, stream->opaque);
	173
	174	lto_destroy_compression_stream (stream);
	175	free (outbuf);
	176	timevar_pop (TV_IPA_LTO_DECOMPRESS);
	177	}
	178
	179	#endif
	180
d7f09764 DN	181	/* Create a new compression stream, with CALLBACK flush function passed
	182	OPAQUE token, IS_COMPRESSION indicates if compressing or uncompressing. */
	183
	184	static struct lto_compression_stream *
	185	lto_new_compression_stream (void (callback) (const char , unsigned, void *),
	186	void *opaque, bool is_compression)
	187	{
	188	struct lto_compression_stream *stream
	189	= (struct lto_compression_stream ) xmalloc (sizeof (stream));
	190
	191	memset (stream, 0, sizeof (*stream));
	192	stream->callback = callback;
	193	stream->opaque = opaque;
	194	stream->is_compression = is_compression;
	195
	196	return stream;
	197	}
	198
	199	/* Append NUM_CHARS from address BASE to STREAM. */
	200
	201	static void
	202	lto_append_to_compression_stream (struct lto_compression_stream *stream,
	203	const char *base, size_t num_chars)
	204	{
	205	size_t required = stream->bytes + num_chars;
	206
	207	if (stream->allocation < required)
	208	{
	209	if (stream->allocation == 0)
	210	stream->allocation = MIN_STREAM_ALLOCATION;
	211	while (stream->allocation < required)
	212	stream->allocation *= 2;
	213
	214	stream->buffer = (char *) xrealloc (stream->buffer, stream->allocation);
	215	}
	216
	217	memcpy (stream->buffer + stream->bytes, base, num_chars);
	218	stream->bytes += num_chars;
	219	}
	220
d7f09764 DN	221	/* Return a new compression stream, with CALLBACK flush function passed
	222	OPAQUE token. */
	223
	224	struct lto_compression_stream *
	225	lto_start_compression (void (callback) (const char , unsigned, void *),
	226	void *opaque)
	227	{
	228	return lto_new_compression_stream (callback, opaque, true);
	229	}
	230
	231	/* Append NUM_CHARS from address BASE to STREAM. */
	232
	233	void
	234	lto_compress_block (struct lto_compression_stream *stream,
	235	const char *base, size_t num_chars)
	236	{
	237	gcc_assert (stream->is_compression);
	238
	239	lto_append_to_compression_stream (stream, base, num_chars);
	240	lto_stats.num_output_il_bytes += num_chars;
	241	}
	242
87741e51 ML	243	static void ATTRIBUTE_UNUSED
87741e51 ML	244	lto_compression_zlib (struct lto_compression_stream *stream)
d7f09764 DN	245	{
	246	unsigned char cursor = (unsigned char ) stream->buffer;
	247	size_t remaining = stream->bytes;
	248	const size_t outbuf_length = Z_BUFFER_LENGTH;
	249	unsigned char outbuf = (unsigned char ) xmalloc (outbuf_length);
	250	z_stream out_stream;
	251	size_t compressed_bytes = 0;
	252	int status;
	253
	254	gcc_assert (stream->is_compression);
	255
ed7dc894 JH	256	timevar_push (TV_IPA_LTO_COMPRESS);
ed7dc894 JH	257
d7f09764 DN	258	out_stream.next_out = outbuf;
	259	out_stream.avail_out = outbuf_length;
	260	out_stream.next_in = cursor;
	261	out_stream.avail_in = remaining;
	262	out_stream.zalloc = lto_zalloc;
	263	out_stream.zfree = lto_zfree;
	264	out_stream.opaque = Z_NULL;
	265
	266	status = deflateInit (&out_stream, lto_normalized_zlib_level ());
	267	if (status != Z_OK)
	268	internal_error ("compressed stream: %s", zError (status));
	269
	270	do
	271	{
	272	size_t in_bytes, out_bytes;
	273
	274	status = deflate (&out_stream, Z_FINISH);
	275	if (status != Z_OK && status != Z_STREAM_END)
	276	internal_error ("compressed stream: %s", zError (status));
	277
	278	in_bytes = remaining - out_stream.avail_in;
	279	out_bytes = outbuf_length - out_stream.avail_out;
	280
	281	stream->callback ((const char *) outbuf, out_bytes, stream->opaque);
	282	lto_stats.num_compressed_il_bytes += out_bytes;
	283	compressed_bytes += out_bytes;
	284
	285	cursor += in_bytes;
	286	remaining -= in_bytes;
	287
	288	out_stream.next_out = outbuf;
	289	out_stream.avail_out = outbuf_length;
	290	out_stream.next_in = cursor;
	291	out_stream.avail_in = remaining;
	292	}
	293	while (status != Z_STREAM_END);
	294
	295	status = deflateEnd (&out_stream);
	296	if (status != Z_OK)
	297	internal_error ("compressed stream: %s", zError (status));
	298
	299	lto_destroy_compression_stream (stream);
	300	free (outbuf);
ed7dc894	301	timevar_pop (TV_IPA_LTO_COMPRESS);
d7f09764 DN	302	}
d7f09764 DN	303
87741e51 ML	304	void
	305	lto_end_compression (struct lto_compression_stream *stream)
	306	{
	307	#ifdef HAVE_ZSTD_H
	308	lto_compression_zstd (stream);
	309	#else
	310	lto_compression_zlib (stream);
	311	#endif
	312	}
	313
d7f09764 DN	314	/* Return a new uncompression stream, with CALLBACK flush function passed
	315	OPAQUE token. */
	316
	317	struct lto_compression_stream *
	318	lto_start_uncompression (void (callback) (const char , unsigned, void *),
	319	void *opaque)
	320	{
	321	return lto_new_compression_stream (callback, opaque, false);
	322	}
	323
	324	/* Append NUM_CHARS from address BASE to STREAM. */
	325
	326	void
	327	lto_uncompress_block (struct lto_compression_stream *stream,
	328	const char *base, size_t num_chars)
	329	{
	330	gcc_assert (!stream->is_compression);
	331
	332	lto_append_to_compression_stream (stream, base, num_chars);
	333	lto_stats.num_input_il_bytes += num_chars;
	334	}
	335
87741e51 ML	336	static void
87741e51 ML	337	lto_uncompression_zlib (struct lto_compression_stream *stream)
d7f09764 DN	338	{
	339	unsigned char cursor = (unsigned char ) stream->buffer;
	340	size_t remaining = stream->bytes;
	341	const size_t outbuf_length = Z_BUFFER_LENGTH;
	342	unsigned char outbuf = (unsigned char ) xmalloc (outbuf_length);
	343	size_t uncompressed_bytes = 0;
	344
	345	gcc_assert (!stream->is_compression);
ed7dc894	346	timevar_push (TV_IPA_LTO_DECOMPRESS);
d7f09764 DN	347
	348	while (remaining > 0)
	349	{
	350	z_stream in_stream;
	351	size_t out_bytes;
	352	int status;
	353
	354	in_stream.next_out = outbuf;
	355	in_stream.avail_out = outbuf_length;
	356	in_stream.next_in = cursor;
	357	in_stream.avail_in = remaining;
	358	in_stream.zalloc = lto_zalloc;
	359	in_stream.zfree = lto_zfree;
	360	in_stream.opaque = Z_NULL;
	361
	362	status = inflateInit (&in_stream);
	363	if (status != Z_OK)
	364	internal_error ("compressed stream: %s", zError (status));
	365
	366	do
	367	{
	368	size_t in_bytes;
	369
	370	status = inflate (&in_stream, Z_SYNC_FLUSH);
	371	if (status != Z_OK && status != Z_STREAM_END)
	372	internal_error ("compressed stream: %s", zError (status));
	373
	374	in_bytes = remaining - in_stream.avail_in;
	375	out_bytes = outbuf_length - in_stream.avail_out;
	376
	377	stream->callback ((const char *) outbuf, out_bytes, stream->opaque);
	378	lto_stats.num_uncompressed_il_bytes += out_bytes;
	379	uncompressed_bytes += out_bytes;
	380
	381	cursor += in_bytes;
	382	remaining -= in_bytes;
	383
	384	in_stream.next_out = outbuf;
	385	in_stream.avail_out = outbuf_length;
	386	in_stream.next_in = cursor;
	387	in_stream.avail_in = remaining;
	388	}
	389	while (!(status == Z_STREAM_END && out_bytes == 0));
	390
	391	status = inflateEnd (&in_stream);
	392	if (status != Z_OK)
	393	internal_error ("compressed stream: %s", zError (status));
	394	}
	395
	396	lto_destroy_compression_stream (stream);
	397	free (outbuf);
ed7dc894	398	timevar_pop (TV_IPA_LTO_DECOMPRESS);
d7f09764	399	}
87741e51 ML	400
	401	void
	402	lto_end_uncompression (struct lto_compression_stream *stream,
	403	lto_compression compression)
	404	{
	405	#ifdef HAVE_ZSTD_H
	406	if (compression == ZSTD)
	407	{
	408	lto_uncompression_zstd (stream);
	409	return;
	410	}
	411	#endif
	412	if (compression == ZSTD)
	413	internal_error ("compiler does not support ZSTD LTO compression");
	414
	415	lto_uncompression_zlib (stream);
	416	}