PR rtl-optimization/86620
[official-gcc.git] / gcc / lto-compress.c
blobe1d8137ff44d2337bda80ffacd0a47fa5466cc27
1 /* LTO IL compression streams.
3 Copyright (C) 2009-2018 Free Software Foundation, Inc.
4 Contributed by Simon Baldwin <simonb@google.com>
6 This file is part of GCC.
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.
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.
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/>. */
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "backend.h"
26 #include "tree.h"
27 #include "gimple.h"
28 #include "cgraph.h"
29 #include "lto-streamer.h"
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>
35 #include "lto-compress.h"
36 #include "timevar.h"
38 /* Compression stream structure, holds the flush callback and opaque token,
39 the buffered data, and a note of whether compressing or uncompressing. */
41 struct lto_compression_stream
43 void (*callback) (const char *, unsigned, void *);
44 void *opaque;
45 char *buffer;
46 size_t bytes;
47 size_t allocation;
48 bool is_compression;
51 /* Overall compression constants for zlib. */
53 static const size_t Z_BUFFER_LENGTH = 4096;
54 static const size_t MIN_STREAM_ALLOCATION = 1024;
56 /* For zlib, allocate SIZE count of ITEMS and return the address, OPAQUE
57 is unused. */
59 static void *
60 lto_zalloc (void *opaque, unsigned items, unsigned size)
62 gcc_assert (opaque == Z_NULL);
63 return xmalloc (items * size);
66 /* For zlib, free memory at ADDRESS, OPAQUE is unused. */
68 static void
69 lto_zfree (void *opaque, void *address)
71 gcc_assert (opaque == Z_NULL);
72 free (address);
75 /* Return a zlib compression level that zlib will not reject. Normalizes
76 the compression level from the command line flag, clamping non-default
77 values to the appropriate end of their valid range. */
79 static int
80 lto_normalized_zlib_level (void)
82 int level = flag_lto_compression_level;
84 if (level != Z_DEFAULT_COMPRESSION)
86 if (level < Z_NO_COMPRESSION)
87 level = Z_NO_COMPRESSION;
88 else if (level > Z_BEST_COMPRESSION)
89 level = Z_BEST_COMPRESSION;
92 return level;
95 /* Create a new compression stream, with CALLBACK flush function passed
96 OPAQUE token, IS_COMPRESSION indicates if compressing or uncompressing. */
98 static struct lto_compression_stream *
99 lto_new_compression_stream (void (*callback) (const char *, unsigned, void *),
100 void *opaque, bool is_compression)
102 struct lto_compression_stream *stream
103 = (struct lto_compression_stream *) xmalloc (sizeof (*stream));
105 memset (stream, 0, sizeof (*stream));
106 stream->callback = callback;
107 stream->opaque = opaque;
108 stream->is_compression = is_compression;
110 return stream;
113 /* Append NUM_CHARS from address BASE to STREAM. */
115 static void
116 lto_append_to_compression_stream (struct lto_compression_stream *stream,
117 const char *base, size_t num_chars)
119 size_t required = stream->bytes + num_chars;
121 if (stream->allocation < required)
123 if (stream->allocation == 0)
124 stream->allocation = MIN_STREAM_ALLOCATION;
125 while (stream->allocation < required)
126 stream->allocation *= 2;
128 stream->buffer = (char *) xrealloc (stream->buffer, stream->allocation);
131 memcpy (stream->buffer + stream->bytes, base, num_chars);
132 stream->bytes += num_chars;
135 /* Free the buffer and memory associated with STREAM. */
137 static void
138 lto_destroy_compression_stream (struct lto_compression_stream *stream)
140 free (stream->buffer);
141 free (stream);
144 /* Return a new compression stream, with CALLBACK flush function passed
145 OPAQUE token. */
147 struct lto_compression_stream *
148 lto_start_compression (void (*callback) (const char *, unsigned, void *),
149 void *opaque)
151 return lto_new_compression_stream (callback, opaque, true);
154 /* Append NUM_CHARS from address BASE to STREAM. */
156 void
157 lto_compress_block (struct lto_compression_stream *stream,
158 const char *base, size_t num_chars)
160 gcc_assert (stream->is_compression);
162 lto_append_to_compression_stream (stream, base, num_chars);
163 lto_stats.num_output_il_bytes += num_chars;
166 /* Finalize STREAM compression, and free stream allocations. */
168 void
169 lto_end_compression (struct lto_compression_stream *stream)
171 unsigned char *cursor = (unsigned char *) stream->buffer;
172 size_t remaining = stream->bytes;
173 const size_t outbuf_length = Z_BUFFER_LENGTH;
174 unsigned char *outbuf = (unsigned char *) xmalloc (outbuf_length);
175 z_stream out_stream;
176 size_t compressed_bytes = 0;
177 int status;
179 gcc_assert (stream->is_compression);
181 timevar_push (TV_IPA_LTO_COMPRESS);
183 out_stream.next_out = outbuf;
184 out_stream.avail_out = outbuf_length;
185 out_stream.next_in = cursor;
186 out_stream.avail_in = remaining;
187 out_stream.zalloc = lto_zalloc;
188 out_stream.zfree = lto_zfree;
189 out_stream.opaque = Z_NULL;
191 status = deflateInit (&out_stream, lto_normalized_zlib_level ());
192 if (status != Z_OK)
193 internal_error ("compressed stream: %s", zError (status));
197 size_t in_bytes, out_bytes;
199 status = deflate (&out_stream, Z_FINISH);
200 if (status != Z_OK && status != Z_STREAM_END)
201 internal_error ("compressed stream: %s", zError (status));
203 in_bytes = remaining - out_stream.avail_in;
204 out_bytes = outbuf_length - out_stream.avail_out;
206 stream->callback ((const char *) outbuf, out_bytes, stream->opaque);
207 lto_stats.num_compressed_il_bytes += out_bytes;
208 compressed_bytes += out_bytes;
210 cursor += in_bytes;
211 remaining -= in_bytes;
213 out_stream.next_out = outbuf;
214 out_stream.avail_out = outbuf_length;
215 out_stream.next_in = cursor;
216 out_stream.avail_in = remaining;
218 while (status != Z_STREAM_END);
220 status = deflateEnd (&out_stream);
221 if (status != Z_OK)
222 internal_error ("compressed stream: %s", zError (status));
224 lto_destroy_compression_stream (stream);
225 free (outbuf);
226 timevar_pop (TV_IPA_LTO_COMPRESS);
229 /* Return a new uncompression stream, with CALLBACK flush function passed
230 OPAQUE token. */
232 struct lto_compression_stream *
233 lto_start_uncompression (void (*callback) (const char *, unsigned, void *),
234 void *opaque)
236 return lto_new_compression_stream (callback, opaque, false);
239 /* Append NUM_CHARS from address BASE to STREAM. */
241 void
242 lto_uncompress_block (struct lto_compression_stream *stream,
243 const char *base, size_t num_chars)
245 gcc_assert (!stream->is_compression);
247 lto_append_to_compression_stream (stream, base, num_chars);
248 lto_stats.num_input_il_bytes += num_chars;
251 /* Finalize STREAM uncompression, and free stream allocations.
253 Because of the way LTO IL streams are compressed, there may be several
254 concatenated compressed segments in the accumulated data, so for this
255 function we iterate decompressions until no data remains. */
257 void
258 lto_end_uncompression (struct lto_compression_stream *stream)
260 unsigned char *cursor = (unsigned char *) stream->buffer;
261 size_t remaining = stream->bytes;
262 const size_t outbuf_length = Z_BUFFER_LENGTH;
263 unsigned char *outbuf = (unsigned char *) xmalloc (outbuf_length);
264 size_t uncompressed_bytes = 0;
266 gcc_assert (!stream->is_compression);
267 timevar_push (TV_IPA_LTO_DECOMPRESS);
269 while (remaining > 0)
271 z_stream in_stream;
272 size_t out_bytes;
273 int status;
275 in_stream.next_out = outbuf;
276 in_stream.avail_out = outbuf_length;
277 in_stream.next_in = cursor;
278 in_stream.avail_in = remaining;
279 in_stream.zalloc = lto_zalloc;
280 in_stream.zfree = lto_zfree;
281 in_stream.opaque = Z_NULL;
283 status = inflateInit (&in_stream);
284 if (status != Z_OK)
285 internal_error ("compressed stream: %s", zError (status));
289 size_t in_bytes;
291 status = inflate (&in_stream, Z_SYNC_FLUSH);
292 if (status != Z_OK && status != Z_STREAM_END)
293 internal_error ("compressed stream: %s", zError (status));
295 in_bytes = remaining - in_stream.avail_in;
296 out_bytes = outbuf_length - in_stream.avail_out;
298 stream->callback ((const char *) outbuf, out_bytes, stream->opaque);
299 lto_stats.num_uncompressed_il_bytes += out_bytes;
300 uncompressed_bytes += out_bytes;
302 cursor += in_bytes;
303 remaining -= in_bytes;
305 in_stream.next_out = outbuf;
306 in_stream.avail_out = outbuf_length;
307 in_stream.next_in = cursor;
308 in_stream.avail_in = remaining;
310 while (!(status == Z_STREAM_END && out_bytes == 0));
312 status = inflateEnd (&in_stream);
313 if (status != Z_OK)
314 internal_error ("compressed stream: %s", zError (status));
317 lto_destroy_compression_stream (stream);
318 free (outbuf);
319 timevar_pop (TV_IPA_LTO_DECOMPRESS);