gcc/lto-section-out.c

   1 /* Functions for writing LTO sections.
   2
   3    Copyright (C) 2009-2014 Free Software Foundation, Inc.
   4    Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 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 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "basic-block.h"
  28 #include "tree-ssa-alias.h"
  29 #include "internal-fn.h"
  30 #include "gimple-expr.h"
  31 #include "is-a.h"
  32 #include "gimple.h"
  33 #include "expr.h"
  34 #include "params.h"
  35 #include "input.h"
  36 #include "hashtab.h"
  37 #include "function.h"
  38 #include "except.h"
  39 #include "langhooks.h"
  40 #include "data-streamer.h"
  41 #include "lto-streamer.h"
  42 #include "lto-compress.h"
  43
  44 static vec<lto_out_decl_state_ptr> decl_state_stack;
  45
  46 /* List of out decl states used by functions.  We use this to
  47    generate the decl directory later. */
  48
  49 vec<lto_out_decl_state_ptr> lto_function_decl_states;
  50
  51
  52 /*****************************************************************************
  53    Output routines shared by all of the serialization passes.
  54 *****************************************************************************/
  55
  56
  57 /* Flush compressed stream data function, sends NUM_CHARS from CHARS
  58    to the append lang hook, OPAQUE is currently always NULL.  */
  59
  60 static void
  61 lto_append_data (const char *chars, unsigned int num_chars, void *opaque)
  62 {
  63   gcc_assert (opaque == NULL);
  64   lang_hooks.lto.append_data (chars, num_chars, opaque);
  65 }
  66
  67 /* Pointer to the current compression stream.  */
  68
  69 static struct lto_compression_stream *compression_stream = NULL;
  70
  71 /* Begin a new output section named NAME. If COMPRESS is true, zlib compress
  72    the section. */
  73
  74 void
  75 lto_begin_section (const char *name, bool compress)
  76 {
  77   lang_hooks.lto.begin_section (name);
  78
  79   /* FIXME lto: for now, suppress compression if the lang_hook that appends
  80      data is anything other than assembler output.  The effect here is that
  81      we get compression of IL only in non-ltrans object files.  */
  82   gcc_assert (compression_stream == NULL);
  83   if (compress)
  84     compression_stream = lto_start_compression (lto_append_data, NULL);
  85 }
  86
  87
  88 /* End the current output section.  */
  89
  90 void
  91 lto_end_section (void)
  92 {
  93   if (compression_stream)
  94     {
  95       lto_end_compression (compression_stream);
  96       compression_stream = NULL;
  97     }
  98   lang_hooks.lto.end_section ();
  99 }
 100
 101
 102 /* Write all of the chars in OBS to the assembler.  Recycle the blocks
 103    in obs as this is being done.  */
 104
 105 void
 106 lto_write_stream (struct lto_output_stream *obs)
 107 {
 108   unsigned int block_size = 1024;
 109   struct lto_char_ptr_base *block;
 110   struct lto_char_ptr_base *next_block;
 111   if (!obs->first_block)
 112     return;
 113
 114   for (block = obs->first_block; block; block = next_block)
 115     {
 116       const char *base = ((char *)block) + sizeof (struct lto_char_ptr_base);
 117       unsigned int num_chars = block_size - sizeof (struct lto_char_ptr_base);
 118
 119       /* If this is not the last block, it is full.  If it is the last
 120          block, left_in_block indicates how many chars are unoccupied in
 121          this block; subtract from num_chars to obtain occupancy.  */
 122       next_block = (struct lto_char_ptr_base *) block->ptr;
 123       if (!next_block)
 124         num_chars -= obs->left_in_block;
 125
 126       /* FIXME lto: WPA mode uses an ELF function as a lang_hook to append
 127          output data.  This hook is not happy with the way that compression
 128          blocks up output differently to the way it's blocked here.  So for
 129          now, we don't compress WPA output.  */
 130       if (compression_stream)
 131         {
 132           lto_compress_block (compression_stream, base, num_chars);
 133           lang_hooks.lto.append_data (NULL, 0, block);
 134         }
 135       else
 136         lang_hooks.lto.append_data (base, num_chars, block);
 137       block_size *= 2;
 138     }
 139 }
 140
 141
 142 /* Adds a new block to output stream OBS.  */
 143
 144 void
 145 lto_append_block (struct lto_output_stream *obs)
 146 {
 147   struct lto_char_ptr_base *new_block;
 148
 149   gcc_assert (obs->left_in_block == 0);
 150
 151   if (obs->first_block == NULL)
 152     {
 153       /* This is the first time the stream has been written
 154          into.  */
 155       obs->block_size = 1024;
 156       new_block = (struct lto_char_ptr_base*) xmalloc (obs->block_size);
 157       obs->first_block = new_block;
 158     }
 159   else
 160     {
 161       struct lto_char_ptr_base *tptr;
 162       /* Get a new block that is twice as big as the last block
 163          and link it into the list.  */
 164       obs->block_size *= 2;
 165       new_block = (struct lto_char_ptr_base*) xmalloc (obs->block_size);
 166       /* The first bytes of the block are reserved as a pointer to
 167          the next block.  Set the chain of the full block to the
 168          pointer to the new block.  */
 169       tptr = obs->current_block;
 170       tptr->ptr = (char *) new_block;
 171     }
 172
 173   /* Set the place for the next char at the first position after the
 174      chain to the next block.  */
 175   obs->current_pointer
 176     = ((char *) new_block) + sizeof (struct lto_char_ptr_base);
 177   obs->current_block = new_block;
 178   /* Null out the newly allocated block's pointer to the next block.  */
 179   new_block->ptr = NULL;
 180   obs->left_in_block = obs->block_size - sizeof (struct lto_char_ptr_base);
 181 }
 182
 183
 184 /* Write raw DATA of length LEN to the output block OB.  */
 185
 186 void
 187 lto_output_data_stream (struct lto_output_stream *obs, const void *data,
 188                         size_t len)
 189 {
 190   while (len)
 191     {
 192       size_t copy;
 193
 194       /* No space left.  */
 195       if (obs->left_in_block == 0)
 196         lto_append_block (obs);
 197
 198       /* Determine how many bytes to copy in this loop.  */
 199       if (len <= obs->left_in_block)
 200         copy = len;
 201       else
 202         copy = obs->left_in_block;
 203
 204       /* Copy the data and do bookkeeping.  */
 205       memcpy (obs->current_pointer, data, copy);
 206       obs->current_pointer += copy;
 207       obs->total_size += copy;
 208       obs->left_in_block -= copy;
 209       data = (const char *) data + copy;
 210       len -= copy;
 211     }
 212 }
 213
 214
 215 /* Lookup NAME in ENCODER.  If NAME is not found, create a new entry in
 216    ENCODER for NAME with the next available index of ENCODER,  then
 217    print the index to OBS.  True is returned if NAME was added to
 218    ENCODER.  The resulting index is stored in THIS_INDEX.
 219
 220    If OBS is NULL, the only action is to add NAME to the encoder. */
 221
 222 bool
 223 lto_output_decl_index (struct lto_output_stream *obs,
 224                        struct lto_tree_ref_encoder *encoder,
 225                        tree name, unsigned int *this_index)
 226 {
 227   bool new_entry_p = FALSE;
 228   bool existed_p;
 229
 230   unsigned int &index
 231     = encoder->tree_hash_table->get_or_insert (name, &existed_p);
 232   if (!existed_p)
 233     {
 234       index = encoder->trees.length ();
 235       encoder->trees.safe_push (name);
 236       new_entry_p = TRUE;
 237     }
 238
 239   if (obs)
 240     streamer_write_uhwi_stream (obs, index);
 241   *this_index = index;
 242   return new_entry_p;
 243 }
 244
 245 /* Output a field DECL to OBS.  */
 246
 247 void
 248 lto_output_field_decl_index (struct lto_out_decl_state *decl_state,
 249                              struct lto_output_stream * obs, tree decl)
 250 {
 251   unsigned int index;
 252   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_FIELD_DECL],
 253                          decl, &index);
 254 }
 255
 256 /* Output a function DECL to OBS.  */
 257
 258 void
 259 lto_output_fn_decl_index (struct lto_out_decl_state *decl_state,
 260                           struct lto_output_stream * obs, tree decl)
 261 {
 262   unsigned int index;
 263   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_FN_DECL],
 264                          decl, &index);
 265 }
 266
 267 /* Output a namespace DECL to OBS.  */
 268
 269 void
 270 lto_output_namespace_decl_index (struct lto_out_decl_state *decl_state,
 271                                  struct lto_output_stream * obs, tree decl)
 272 {
 273   unsigned int index;
 274   lto_output_decl_index (obs,
 275                          &decl_state->streams[LTO_DECL_STREAM_NAMESPACE_DECL],
 276                          decl, &index);
 277 }
 278
 279 /* Output a static or extern var DECL to OBS.  */
 280
 281 void
 282 lto_output_var_decl_index (struct lto_out_decl_state *decl_state,
 283                            struct lto_output_stream * obs, tree decl)
 284 {
 285   unsigned int index;
 286   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_VAR_DECL],
 287                          decl, &index);
 288 }
 289
 290 /* Output a type DECL to OBS.  */
 291
 292 void
 293 lto_output_type_decl_index (struct lto_out_decl_state *decl_state,
 294                             struct lto_output_stream * obs, tree decl)
 295 {
 296   unsigned int index;
 297   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_TYPE_DECL],
 298                          decl, &index);
 299 }
 300
 301 /* Output a type REF to OBS.  */
 302
 303 void
 304 lto_output_type_ref_index (struct lto_out_decl_state *decl_state,
 305                            struct lto_output_stream *obs, tree ref)
 306 {
 307   unsigned int index;
 308   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_TYPE],
 309                          ref, &index);
 310 }
 311
 312
 313 /* Create the output block and return it.  */
 314
 315 struct lto_simple_output_block *
 316 lto_create_simple_output_block (enum lto_section_type section_type)
 317 {
 318   struct lto_simple_output_block *ob
 319     = ((struct lto_simple_output_block *)
 320        xcalloc (1, sizeof (struct lto_simple_output_block)));
 321
 322   ob->section_type = section_type;
 323   ob->decl_state = lto_get_out_decl_state ();
 324   ob->main_stream = ((struct lto_output_stream *)
 325                      xcalloc (1, sizeof (struct lto_output_stream)));
 326
 327   return ob;
 328 }
 329
 330
 331 /* Produce a simple section for one of the ipa passes.  */
 332
 333 void
 334 lto_destroy_simple_output_block (struct lto_simple_output_block *ob)
 335 {
 336   char *section_name;
 337   struct lto_simple_header header;
 338   struct lto_output_stream *header_stream;
 339
 340   section_name = lto_get_section_name (ob->section_type, NULL, NULL);
 341   lto_begin_section (section_name, !flag_wpa);
 342   free (section_name);
 343
 344   /* Write the header which says how to decode the pieces of the
 345      t.  */
 346   memset (&header, 0, sizeof (struct lto_simple_header));
 347   header.lto_header.major_version = LTO_major_version;
 348   header.lto_header.minor_version = LTO_minor_version;
 349
 350   header.compressed_size = 0;
 351
 352   header.main_size = ob->main_stream->total_size;
 353
 354   header_stream = XCNEW (struct lto_output_stream);
 355   lto_output_data_stream (header_stream, &header, sizeof header);
 356   lto_write_stream (header_stream);
 357   free (header_stream);
 358
 359   lto_write_stream (ob->main_stream);
 360
 361   /* Put back the assembly section that was there before we started
 362      writing lto info.  */
 363   lto_end_section ();
 364
 365   free (ob->main_stream);
 366   free (ob);
 367 }
 368
 369
 370 /* Return a new lto_out_decl_state. */
 371
 372 struct lto_out_decl_state *
 373 lto_new_out_decl_state (void)
 374 {
 375   struct lto_out_decl_state *state = XCNEW (struct lto_out_decl_state);
 376   int i;
 377
 378   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 379     lto_init_tree_ref_encoder (&state->streams[i]);
 380
 381   return state;
 382 }
 383
 384
 385 /* Delete STATE and components.  */
 386
 387 void
 388 lto_delete_out_decl_state (struct lto_out_decl_state *state)
 389 {
 390   int i;
 391
 392   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 393     lto_destroy_tree_ref_encoder (&state->streams[i]);
 394
 395   free (state);
 396 }
 397
 398
 399 /* Get the currently used lto_out_decl_state structure. */
 400
 401 struct lto_out_decl_state *
 402 lto_get_out_decl_state (void)
 403 {
 404   return decl_state_stack.last ();
 405 }
 406
 407 /* Push STATE to top of out decl stack. */
 408
 409 void
 410 lto_push_out_decl_state (struct lto_out_decl_state *state)
 411 {
 412   decl_state_stack.safe_push (state);
 413 }
 414
 415 /* Pop the currently used out-decl state from top of stack. */
 416
 417 struct lto_out_decl_state *
 418 lto_pop_out_decl_state (void)
 419 {
 420   return decl_state_stack.pop ();
 421 }
 422
 423 /* Record STATE after it has been used in serializing the body of
 424    FN_DECL.  STATE should no longer be used by the caller.  The ownership
 425    of it is taken over from this point.  */
 426
 427 void
 428 lto_record_function_out_decl_state (tree fn_decl,
 429                                     struct lto_out_decl_state *state)
 430 {
 431   int i;
 432
 433   /* Strip all hash tables to save some memory. */
 434   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 435     if (state->streams[i].tree_hash_table)
 436       {
 437         delete state->streams[i].tree_hash_table;
 438         state->streams[i].tree_hash_table = NULL;
 439       }
 440   state->fn_decl = fn_decl;
 441   lto_function_decl_states.safe_push (state);
 442 }