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 /* Write SIZE bytes starting at DATA to the assembler.  */
 102
 103 void
 104 lto_write_data (const void *data, unsigned int size)
 105 {
 106   if (compression_stream)
 107     lto_compress_block (compression_stream, (const char *)data, size);
 108   else
 109     lang_hooks.lto.append_data ((const char *)data, size, NULL);
 110 }
 111
 112 /* Write all of the chars in OBS to the assembler.  Recycle the blocks
 113    in obs as this is being done.  */
 114
 115 void
 116 lto_write_stream (struct lto_output_stream *obs)
 117 {
 118   unsigned int block_size = 1024;
 119   struct lto_char_ptr_base *block;
 120   struct lto_char_ptr_base *next_block;
 121   if (!obs->first_block)
 122     return;
 123
 124   for (block = obs->first_block; block; block = next_block)
 125     {
 126       const char *base = ((char *)block) + sizeof (struct lto_char_ptr_base);
 127       unsigned int num_chars = block_size - sizeof (struct lto_char_ptr_base);
 128
 129       /* If this is not the last block, it is full.  If it is the last
 130          block, left_in_block indicates how many chars are unoccupied in
 131          this block; subtract from num_chars to obtain occupancy.  */
 132       next_block = (struct lto_char_ptr_base *) block->ptr;
 133       if (!next_block)
 134         num_chars -= obs->left_in_block;
 135
 136       /* FIXME lto: WPA mode uses an ELF function as a lang_hook to append
 137          output data.  This hook is not happy with the way that compression
 138          blocks up output differently to the way it's blocked here.  So for
 139          now, we don't compress WPA output.  */
 140       if (compression_stream)
 141         lto_compress_block (compression_stream, base, num_chars);
 142       else
 143         lang_hooks.lto.append_data (base, num_chars, block);
 144       free (block);
 145       block_size *= 2;
 146     }
 147 }
 148
 149
 150 /* Adds a new block to output stream OBS.  */
 151
 152 void
 153 lto_append_block (struct lto_output_stream *obs)
 154 {
 155   struct lto_char_ptr_base *new_block;
 156
 157   gcc_assert (obs->left_in_block == 0);
 158
 159   if (obs->first_block == NULL)
 160     {
 161       /* This is the first time the stream has been written
 162          into.  */
 163       obs->block_size = 1024;
 164       new_block = (struct lto_char_ptr_base*) xmalloc (obs->block_size);
 165       obs->first_block = new_block;
 166     }
 167   else
 168     {
 169       struct lto_char_ptr_base *tptr;
 170       /* Get a new block that is twice as big as the last block
 171          and link it into the list.  */
 172       obs->block_size *= 2;
 173       new_block = (struct lto_char_ptr_base*) xmalloc (obs->block_size);
 174       /* The first bytes of the block are reserved as a pointer to
 175          the next block.  Set the chain of the full block to the
 176          pointer to the new block.  */
 177       tptr = obs->current_block;
 178       tptr->ptr = (char *) new_block;
 179     }
 180
 181   /* Set the place for the next char at the first position after the
 182      chain to the next block.  */
 183   obs->current_pointer
 184     = ((char *) new_block) + sizeof (struct lto_char_ptr_base);
 185   obs->current_block = new_block;
 186   /* Null out the newly allocated block's pointer to the next block.  */
 187   new_block->ptr = NULL;
 188   obs->left_in_block = obs->block_size - sizeof (struct lto_char_ptr_base);
 189 }
 190
 191
 192 /* Write raw DATA of length LEN to the output block OB.  */
 193
 194 void
 195 lto_output_data_stream (struct lto_output_stream *obs, const void *data,
 196                         size_t len)
 197 {
 198   while (len)
 199     {
 200       size_t copy;
 201
 202       /* No space left.  */
 203       if (obs->left_in_block == 0)
 204         lto_append_block (obs);
 205
 206       /* Determine how many bytes to copy in this loop.  */
 207       if (len <= obs->left_in_block)
 208         copy = len;
 209       else
 210         copy = obs->left_in_block;
 211
 212       /* Copy the data and do bookkeeping.  */
 213       memcpy (obs->current_pointer, data, copy);
 214       obs->current_pointer += copy;
 215       obs->total_size += copy;
 216       obs->left_in_block -= copy;
 217       data = (const char *) data + copy;
 218       len -= copy;
 219     }
 220 }
 221
 222
 223 /* Lookup NAME in ENCODER.  If NAME is not found, create a new entry in
 224    ENCODER for NAME with the next available index of ENCODER,  then
 225    print the index to OBS.  True is returned if NAME was added to
 226    ENCODER.  The resulting index is stored in THIS_INDEX.
 227
 228    If OBS is NULL, the only action is to add NAME to the encoder. */
 229
 230 bool
 231 lto_output_decl_index (struct lto_output_stream *obs,
 232                        struct lto_tree_ref_encoder *encoder,
 233                        tree name, unsigned int *this_index)
 234 {
 235   bool new_entry_p = FALSE;
 236   bool existed_p;
 237
 238   unsigned int &index
 239     = encoder->tree_hash_table->get_or_insert (name, &existed_p);
 240   if (!existed_p)
 241     {
 242       index = encoder->trees.length ();
 243       encoder->trees.safe_push (name);
 244       new_entry_p = TRUE;
 245     }
 246
 247   if (obs)
 248     streamer_write_uhwi_stream (obs, index);
 249   *this_index = index;
 250   return new_entry_p;
 251 }
 252
 253 /* Output a field DECL to OBS.  */
 254
 255 void
 256 lto_output_field_decl_index (struct lto_out_decl_state *decl_state,
 257                              struct lto_output_stream * obs, tree decl)
 258 {
 259   unsigned int index;
 260   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_FIELD_DECL],
 261                          decl, &index);
 262 }
 263
 264 /* Output a function DECL to OBS.  */
 265
 266 void
 267 lto_output_fn_decl_index (struct lto_out_decl_state *decl_state,
 268                           struct lto_output_stream * obs, tree decl)
 269 {
 270   unsigned int index;
 271   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_FN_DECL],
 272                          decl, &index);
 273 }
 274
 275 /* Output a namespace DECL to OBS.  */
 276
 277 void
 278 lto_output_namespace_decl_index (struct lto_out_decl_state *decl_state,
 279                                  struct lto_output_stream * obs, tree decl)
 280 {
 281   unsigned int index;
 282   lto_output_decl_index (obs,
 283                          &decl_state->streams[LTO_DECL_STREAM_NAMESPACE_DECL],
 284                          decl, &index);
 285 }
 286
 287 /* Output a static or extern var DECL to OBS.  */
 288
 289 void
 290 lto_output_var_decl_index (struct lto_out_decl_state *decl_state,
 291                            struct lto_output_stream * obs, tree decl)
 292 {
 293   unsigned int index;
 294   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_VAR_DECL],
 295                          decl, &index);
 296 }
 297
 298 /* Output a type DECL to OBS.  */
 299
 300 void
 301 lto_output_type_decl_index (struct lto_out_decl_state *decl_state,
 302                             struct lto_output_stream * obs, tree decl)
 303 {
 304   unsigned int index;
 305   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_TYPE_DECL],
 306                          decl, &index);
 307 }
 308
 309 /* Output a type REF to OBS.  */
 310
 311 void
 312 lto_output_type_ref_index (struct lto_out_decl_state *decl_state,
 313                            struct lto_output_stream *obs, tree ref)
 314 {
 315   unsigned int index;
 316   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_TYPE],
 317                          ref, &index);
 318 }
 319
 320
 321 /* Create the output block and return it.  */
 322
 323 struct lto_simple_output_block *
 324 lto_create_simple_output_block (enum lto_section_type section_type)
 325 {
 326   struct lto_simple_output_block *ob
 327     = ((struct lto_simple_output_block *)
 328        xcalloc (1, sizeof (struct lto_simple_output_block)));
 329
 330   ob->section_type = section_type;
 331   ob->decl_state = lto_get_out_decl_state ();
 332   ob->main_stream = ((struct lto_output_stream *)
 333                      xcalloc (1, sizeof (struct lto_output_stream)));
 334
 335   return ob;
 336 }
 337
 338
 339 /* Produce a simple section for one of the ipa passes.  */
 340
 341 void
 342 lto_destroy_simple_output_block (struct lto_simple_output_block *ob)
 343 {
 344   char *section_name;
 345   struct lto_simple_header header;
 346
 347   section_name = lto_get_section_name (ob->section_type, NULL, NULL);
 348   lto_begin_section (section_name, !flag_wpa);
 349   free (section_name);
 350
 351   /* Write the header which says how to decode the pieces of the
 352      t.  */
 353   memset (&header, 0, sizeof (struct lto_simple_header));
 354   header.lto_header.major_version = LTO_major_version;
 355   header.lto_header.minor_version = LTO_minor_version;
 356   header.compressed_size = 0;
 357   header.main_size = ob->main_stream->total_size;
 358   lto_write_data (&header, sizeof header);
 359
 360   lto_write_stream (ob->main_stream);
 361
 362   /* Put back the assembly section that was there before we started
 363      writing lto info.  */
 364   lto_end_section ();
 365
 366   free (ob->main_stream);
 367   free (ob);
 368 }
 369
 370
 371 /* Return a new lto_out_decl_state. */
 372
 373 struct lto_out_decl_state *
 374 lto_new_out_decl_state (void)
 375 {
 376   struct lto_out_decl_state *state = XCNEW (struct lto_out_decl_state);
 377   int i;
 378
 379   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 380     lto_init_tree_ref_encoder (&state->streams[i]);
 381
 382   return state;
 383 }
 384
 385
 386 /* Delete STATE and components.  */
 387
 388 void
 389 lto_delete_out_decl_state (struct lto_out_decl_state *state)
 390 {
 391   int i;
 392
 393   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 394     lto_destroy_tree_ref_encoder (&state->streams[i]);
 395
 396   free (state);
 397 }
 398
 399
 400 /* Get the currently used lto_out_decl_state structure. */
 401
 402 struct lto_out_decl_state *
 403 lto_get_out_decl_state (void)
 404 {
 405   return decl_state_stack.last ();
 406 }
 407
 408 /* Push STATE to top of out decl stack. */
 409
 410 void
 411 lto_push_out_decl_state (struct lto_out_decl_state *state)
 412 {
 413   decl_state_stack.safe_push (state);
 414 }
 415
 416 /* Pop the currently used out-decl state from top of stack. */
 417
 418 struct lto_out_decl_state *
 419 lto_pop_out_decl_state (void)
 420 {
 421   return decl_state_stack.pop ();
 422 }
 423
 424 /* Record STATE after it has been used in serializing the body of
 425    FN_DECL.  STATE should no longer be used by the caller.  The ownership
 426    of it is taken over from this point.  */
 427
 428 void
 429 lto_record_function_out_decl_state (tree fn_decl,
 430                                     struct lto_out_decl_state *state)
 431 {
 432   int i;
 433
 434   /* Strip all hash tables to save some memory. */
 435   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 436     if (state->streams[i].tree_hash_table)
 437       {
 438         delete state->streams[i].tree_hash_table;
 439         state->streams[i].tree_hash_table = NULL;
 440       }
 441   state->fn_decl = fn_decl;
 442   lto_function_decl_states.safe_push (state);
 443 }