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