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

/* LTO IL compression streams.

   Copyright (C) 2009-2015 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"
/* 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 "coretypes.h"
#include "alias.h"
#include "symtab.h"
#include "options.h"
#include "tree.h"
#include "fold-const.h"
#include "predict.h"
#include "tm.h"
#include "hard-reg-set.h"
#include "function.h"
#include "basic-block.h"
#include "tree-ssa-alias.h"
#include "internal-fn.h"
#include "gimple-expr.h"
#include "gimple.h"
#include "diagnostic-core.h"
#include "langhooks.h"
#include "plugin-api.h"
#include "ipa-ref.h"
#include "cgraph.h"
#include "lto-streamer.h"
#include "lto-compress.h"

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

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

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

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

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

/* Finalize STREAM compression, and free stream allocations.  */

void
lto_end_compression (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);

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

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

/* Finalize STREAM uncompression, and free stream allocations.

   Because of the way LTO IL streams are compressed, there may be several
   concatenated compressed segments in the accumulated data, so for this
   function we iterate decompressions until no data remains.  */

void
lto_end_uncompression (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);

  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);
}
Commit	Line	Data
7bfefa9d	1	/* LTO IL compression streams.
7bfefa9d	2
d353bf18	3	Copyright (C) 2009-2015 Free Software Foundation, Inc.
7bfefa9d	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"
	24	/* zlib.h includes other system headers. Those headers may test feature
	25	test macros. config.h may define feature test macros. For this reason,
	26	zlib.h needs to be included after, rather than before, config.h and
	27	system.h. */
	28	#include <zlib.h>
	29	#include "coretypes.h"
b20a8bb4	30	#include "alias.h"
	31	#include "symtab.h"
	32	#include "options.h"
b20a8bb4	33	#include "tree.h"
	34	#include "fold-const.h"
	35	#include "predict.h"
94ea8568	36	#include "tm.h"
94ea8568	37	#include "hard-reg-set.h"
94ea8568	38	#include "function.h"
bc61cadb	39	#include "basic-block.h"
	40	#include "tree-ssa-alias.h"
	41	#include "internal-fn.h"
	42	#include "gimple-expr.h"
b23fb4cb	43	#include "gimple.h"
852f689e	44	#include "diagnostic-core.h"
7bfefa9d	45	#include "langhooks.h"
1140c305	46	#include "plugin-api.h"
	47	#include "ipa-ref.h"
	48	#include "cgraph.h"
7bfefa9d	49	#include "lto-streamer.h"
	50	#include "lto-compress.h"
	51
	52	/* Compression stream structure, holds the flush callback and opaque token,
	53	the buffered data, and a note of whether compressing or uncompressing. */
	54
	55	struct lto_compression_stream
	56	{
	57	void (callback) (const char , unsigned, void *);
	58	void *opaque;
	59	char *buffer;
	60	size_t bytes;
	61	size_t allocation;
	62	bool is_compression;
	63	};
	64
	65	/* Overall compression constants for zlib. */
	66
	67	static const size_t Z_BUFFER_LENGTH = 4096;
	68	static const size_t MIN_STREAM_ALLOCATION = 1024;
	69
	70	/* For zlib, allocate SIZE count of ITEMS and return the address, OPAQUE
	71	is unused. */
	72
	73	static void *
	74	lto_zalloc (void *opaque, unsigned items, unsigned size)
	75	{
	76	gcc_assert (opaque == Z_NULL);
	77	return xmalloc (items * size);
	78	}
	79
	80	/* For zlib, free memory at ADDRESS, OPAQUE is unused. */
	81
	82	static void
	83	lto_zfree (void opaque, void address)
	84	{
	85	gcc_assert (opaque == Z_NULL);
	86	free (address);
	87	}
	88
	89	/* Return a zlib compression level that zlib will not reject. Normalizes
	90	the compression level from the command line flag, clamping non-default
	91	values to the appropriate end of their valid range. */
	92
	93	static int
	94	lto_normalized_zlib_level (void)
	95	{
	96	int level = flag_lto_compression_level;
	97
	98	if (level != Z_DEFAULT_COMPRESSION)
	99	{
	100	if (level < Z_NO_COMPRESSION)
	101	level = Z_NO_COMPRESSION;
	102	else if (level > Z_BEST_COMPRESSION)
	103	level = Z_BEST_COMPRESSION;
	104	}
	105
	106	return level;
	107	}
	108
	109	/* Create a new compression stream, with CALLBACK flush function passed
	110	OPAQUE token, IS_COMPRESSION indicates if compressing or uncompressing. */
	111
	112	static struct lto_compression_stream *
113	lto_new_compression_stream (void (callback) (const char , unsigned, void *),
114	void *opaque, bool is_compression)
115	{
116	struct lto_compression_stream *stream
117	= (struct lto_compression_stream ) xmalloc (sizeof (stream));
118
119	memset (stream, 0, sizeof (*stream));
120	stream->callback = callback;
121	stream->opaque = opaque;
122	stream->is_compression = is_compression;
123
124	return stream;
125	}
126
127	/* Append NUM_CHARS from address BASE to STREAM. */
128
129	static void
130	lto_append_to_compression_stream (struct lto_compression_stream *stream,
131	const char *base, size_t num_chars)
132	{
133	size_t required = stream->bytes + num_chars;
134
135	if (stream->allocation < required)
136	{
137	if (stream->allocation == 0)
138	stream->allocation = MIN_STREAM_ALLOCATION;
139	while (stream->allocation < required)
140	stream->allocation *= 2;
141
142	stream->buffer = (char *) xrealloc (stream->buffer, stream->allocation);
143	}
144
145	memcpy (stream->buffer + stream->bytes, base, num_chars);
146	stream->bytes += num_chars;
147	}
148
149	/* Free the buffer and memory associated with STREAM. */
150
151	static void
152	lto_destroy_compression_stream (struct lto_compression_stream *stream)
153	{
154	free (stream->buffer);
155	free (stream);
156	}
157
158	/* Return a new compression stream, with CALLBACK flush function passed
159	OPAQUE token. */
160
161	struct lto_compression_stream *
162	lto_start_compression (void (callback) (const char , unsigned, void *),
163	void *opaque)
164	{
165	return lto_new_compression_stream (callback, opaque, true);
166	}
167
168	/* Append NUM_CHARS from address BASE to STREAM. */
169
170	void
171	lto_compress_block (struct lto_compression_stream *stream,
172	const char *base, size_t num_chars)
173	{
174	gcc_assert (stream->is_compression);
175
176	lto_append_to_compression_stream (stream, base, num_chars);
177	lto_stats.num_output_il_bytes += num_chars;
178	}
179
180	/* Finalize STREAM compression, and free stream allocations. */
181
182	void
183	lto_end_compression (struct lto_compression_stream *stream)
184	{
185	unsigned char cursor = (unsigned char ) stream->buffer;
186	size_t remaining = stream->bytes;
187	const size_t outbuf_length = Z_BUFFER_LENGTH;
188	unsigned char outbuf = (unsigned char ) xmalloc (outbuf_length);
189	z_stream out_stream;
190	size_t compressed_bytes = 0;
191	int status;
192
193	gcc_assert (stream->is_compression);
194
195	out_stream.next_out = outbuf;
196	out_stream.avail_out = outbuf_length;
197	out_stream.next_in = cursor;
198	out_stream.avail_in = remaining;
199	out_stream.zalloc = lto_zalloc;
200	out_stream.zfree = lto_zfree;
201	out_stream.opaque = Z_NULL;
202
203	status = deflateInit (&out_stream, lto_normalized_zlib_level ());
204	if (status != Z_OK)
205	internal_error ("compressed stream: %s", zError (status));
206
207	do
208	{
209	size_t in_bytes, out_bytes;
210
211	status = deflate (&out_stream, Z_FINISH);
212	if (status != Z_OK && status != Z_STREAM_END)
213	internal_error ("compressed stream: %s", zError (status));
214
215	in_bytes = remaining - out_stream.avail_in;
216	out_bytes = outbuf_length - out_stream.avail_out;
217
218	stream->callback ((const char *) outbuf, out_bytes, stream->opaque);
219	lto_stats.num_compressed_il_bytes += out_bytes;
220	compressed_bytes += out_bytes;
221
222	cursor += in_bytes;
223	remaining -= in_bytes;
224
225	out_stream.next_out = outbuf;
226	out_stream.avail_out = outbuf_length;
227	out_stream.next_in = cursor;
228	out_stream.avail_in = remaining;
229	}
230	while (status != Z_STREAM_END);
231
232	status = deflateEnd (&out_stream);
233	if (status != Z_OK)
234	internal_error ("compressed stream: %s", zError (status));
235
236	lto_destroy_compression_stream (stream);
237	free (outbuf);
238	}
239
240	/* Return a new uncompression stream, with CALLBACK flush function passed
241	OPAQUE token. */
242
243	struct lto_compression_stream *
244	lto_start_uncompression (void (callback) (const char , unsigned, void *),
245	void *opaque)
246	{
247	return lto_new_compression_stream (callback, opaque, false);
248	}
249
250	/* Append NUM_CHARS from address BASE to STREAM. */
251
252	void
253	lto_uncompress_block (struct lto_compression_stream *stream,
254	const char *base, size_t num_chars)
255	{
256	gcc_assert (!stream->is_compression);
257
258	lto_append_to_compression_stream (stream, base, num_chars);
259	lto_stats.num_input_il_bytes += num_chars;
260	}
261
262	/* Finalize STREAM uncompression, and free stream allocations.
48e1416a	263
7bfefa9d	264	Because of the way LTO IL streams are compressed, there may be several
	265	concatenated compressed segments in the accumulated data, so for this
	266	function we iterate decompressions until no data remains. */
	267
	268	void
	269	lto_end_uncompression (struct lto_compression_stream *stream)
	270	{
	271	unsigned char cursor = (unsigned char ) stream->buffer;
	272	size_t remaining = stream->bytes;
	273	const size_t outbuf_length = Z_BUFFER_LENGTH;
	274	unsigned char outbuf = (unsigned char ) xmalloc (outbuf_length);
	275	size_t uncompressed_bytes = 0;
	276
	277	gcc_assert (!stream->is_compression);
	278
	279	while (remaining > 0)
	280	{
	281	z_stream in_stream;
	282	size_t out_bytes;
	283	int status;
	284
	285	in_stream.next_out = outbuf;
	286	in_stream.avail_out = outbuf_length;
	287	in_stream.next_in = cursor;
	288	in_stream.avail_in = remaining;
	289	in_stream.zalloc = lto_zalloc;
	290	in_stream.zfree = lto_zfree;
	291	in_stream.opaque = Z_NULL;
	292
	293	status = inflateInit (&in_stream);
	294	if (status != Z_OK)
	295	internal_error ("compressed stream: %s", zError (status));
	296
	297	do
	298	{
	299	size_t in_bytes;
	300
	301	status = inflate (&in_stream, Z_SYNC_FLUSH);
	302	if (status != Z_OK && status != Z_STREAM_END)
	303	internal_error ("compressed stream: %s", zError (status));
	304
	305	in_bytes = remaining - in_stream.avail_in;
	306	out_bytes = outbuf_length - in_stream.avail_out;
	307
	308	stream->callback ((const char *) outbuf, out_bytes, stream->opaque);
	309	lto_stats.num_uncompressed_il_bytes += out_bytes;
	310	uncompressed_bytes += out_bytes;
	311
	312	cursor += in_bytes;
	313	remaining -= in_bytes;
	314
	315	in_stream.next_out = outbuf;
	316	in_stream.avail_out = outbuf_length;
	317	in_stream.next_in = cursor;
	318	in_stream.avail_in = remaining;
	319	}
	320	while (!(status == Z_STREAM_END && out_bytes == 0));
	321
	322	status = inflateEnd (&in_stream);
	323	if (status != Z_OK)
	324	internal_error ("compressed stream: %s", zError (status));
	325	}
	326
	327	lto_destroy_compression_stream (stream);
328	free (outbuf);
329	}