gcc/lto-compress.c

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