gcc/lto-section-out.c

   1 /* Functions for writing LTO sections.
   2
   3    Copyright (C) 2009-2015 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 "alias.h"
  27 #include "symtab.h"
  28 #include "tree.h"
  29 #include "fold-const.h"
  30 #include "predict.h"
  31 #include "hard-reg-set.h"
  32 #include "function.h"
  33 #include "basic-block.h"
  34 #include "tree-ssa-alias.h"
  35 #include "internal-fn.h"
  36 #include "gimple-expr.h"
  37 #include "gimple.h"
  38 #include "rtl.h"
  39 #include "flags.h"
  40 #include "insn-config.h"
  41 #include "expmed.h"
  42 #include "dojump.h"
  43 #include "explow.h"
  44 #include "calls.h"
  45 #include "emit-rtl.h"
  46 #include "varasm.h"
  47 #include "stmt.h"
  48 #include "expr.h"
  49 #include "params.h"
  50 #include "except.h"
  51 #include "langhooks.h"
  52 #include "plugin-api.h"
  53 #include "ipa-ref.h"
  54 #include "cgraph.h"
  55 #include "data-streamer.h"
  56 #include "lto-streamer.h"
  57 #include "lto-compress.h"
  58
  59 static vec<lto_out_decl_state_ptr> decl_state_stack;
  60
  61 /* List of out decl states used by functions.  We use this to
  62    generate the decl directory later. */
  63
  64 vec<lto_out_decl_state_ptr> lto_function_decl_states;
  65
  66
  67 /*****************************************************************************
  68    Output routines shared by all of the serialization passes.
  69 *****************************************************************************/
  70
  71
  72 /* Flush compressed stream data function, sends NUM_CHARS from CHARS
  73    to the append lang hook, OPAQUE is currently always NULL.  */
  74
  75 static void
  76 lto_append_data (const char *chars, unsigned int num_chars, void *opaque)
  77 {
  78   gcc_assert (opaque == NULL);
  79   lang_hooks.lto.append_data (chars, num_chars, opaque);
  80 }
  81
  82 /* Pointer to the current compression stream.  */
  83
  84 static struct lto_compression_stream *compression_stream = NULL;
  85
  86 /* Begin a new output section named NAME. If COMPRESS is true, zlib compress
  87    the section. */
  88
  89 void
  90 lto_begin_section (const char *name, bool compress)
  91 {
  92   lang_hooks.lto.begin_section (name);
  93
  94   /* FIXME lto: for now, suppress compression if the lang_hook that appends
  95      data is anything other than assembler output.  The effect here is that
  96      we get compression of IL only in non-ltrans object files.  */
  97   gcc_assert (compression_stream == NULL);
  98   if (compress)
  99     compression_stream = lto_start_compression (lto_append_data, NULL);
 100 }
 101
 102
 103 /* End the current output section.  */
 104
 105 void
 106 lto_end_section (void)
 107 {
 108   if (compression_stream)
 109     {
 110       lto_end_compression (compression_stream);
 111       compression_stream = NULL;
 112     }
 113   lang_hooks.lto.end_section ();
 114 }
 115
 116 /* Write SIZE bytes starting at DATA to the assembler.  */
 117
 118 void
 119 lto_write_data (const void *data, unsigned int size)
 120 {
 121   if (compression_stream)
 122     lto_compress_block (compression_stream, (const char *)data, size);
 123   else
 124     lang_hooks.lto.append_data ((const char *)data, size, NULL);
 125 }
 126
 127 /* Write all of the chars in OBS to the assembler.  Recycle the blocks
 128    in obs as this is being done.  */
 129
 130 void
 131 lto_write_stream (struct lto_output_stream *obs)
 132 {
 133   unsigned int block_size = 1024;
 134   struct lto_char_ptr_base *block;
 135   struct lto_char_ptr_base *next_block;
 136   if (!obs->first_block)
 137     return;
 138
 139   for (block = obs->first_block; block; block = next_block)
 140     {
 141       const char *base = ((char *)block) + sizeof (struct lto_char_ptr_base);
 142       unsigned int num_chars = block_size - sizeof (struct lto_char_ptr_base);
 143
 144       /* If this is not the last block, it is full.  If it is the last
 145          block, left_in_block indicates how many chars are unoccupied in
 146          this block; subtract from num_chars to obtain occupancy.  */
 147       next_block = (struct lto_char_ptr_base *) block->ptr;
 148       if (!next_block)
 149         num_chars -= obs->left_in_block;
 150
 151       /* FIXME lto: WPA mode uses an ELF function as a lang_hook to append
 152          output data.  This hook is not happy with the way that compression
 153          blocks up output differently to the way it's blocked here.  So for
 154          now, we don't compress WPA output.  */
 155       if (compression_stream)
 156         lto_compress_block (compression_stream, base, num_chars);
 157       else
 158         lang_hooks.lto.append_data (base, num_chars, block);
 159       free (block);
 160       block_size *= 2;
 161     }
 162 }
 163
 164
 165 /* Lookup NAME in ENCODER.  If NAME is not found, create a new entry in
 166    ENCODER for NAME with the next available index of ENCODER,  then
 167    print the index to OBS.  True is returned if NAME was added to
 168    ENCODER.  The resulting index is stored in THIS_INDEX.
 169
 170    If OBS is NULL, the only action is to add NAME to the encoder. */
 171
 172 bool
 173 lto_output_decl_index (struct lto_output_stream *obs,
 174                        struct lto_tree_ref_encoder *encoder,
 175                        tree name, unsigned int *this_index)
 176 {
 177   bool new_entry_p = FALSE;
 178   bool existed_p;
 179
 180   unsigned int &index
 181     = encoder->tree_hash_table->get_or_insert (name, &existed_p);
 182   if (!existed_p)
 183     {
 184       index = encoder->trees.length ();
 185       encoder->trees.safe_push (name);
 186       new_entry_p = TRUE;
 187     }
 188
 189   if (obs)
 190     streamer_write_uhwi_stream (obs, index);
 191   *this_index = index;
 192   return new_entry_p;
 193 }
 194
 195 /* Output a field DECL to OBS.  */
 196
 197 void
 198 lto_output_field_decl_index (struct lto_out_decl_state *decl_state,
 199                              struct lto_output_stream * obs, tree decl)
 200 {
 201   unsigned int index;
 202   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_FIELD_DECL],
 203                          decl, &index);
 204 }
 205
 206 /* Output a function DECL to OBS.  */
 207
 208 void
 209 lto_output_fn_decl_index (struct lto_out_decl_state *decl_state,
 210                           struct lto_output_stream * obs, tree decl)
 211 {
 212   unsigned int index;
 213   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_FN_DECL],
 214                          decl, &index);
 215 }
 216
 217 /* Output a namespace DECL to OBS.  */
 218
 219 void
 220 lto_output_namespace_decl_index (struct lto_out_decl_state *decl_state,
 221                                  struct lto_output_stream * obs, tree decl)
 222 {
 223   unsigned int index;
 224   lto_output_decl_index (obs,
 225                          &decl_state->streams[LTO_DECL_STREAM_NAMESPACE_DECL],
 226                          decl, &index);
 227 }
 228
 229 /* Output a static or extern var DECL to OBS.  */
 230
 231 void
 232 lto_output_var_decl_index (struct lto_out_decl_state *decl_state,
 233                            struct lto_output_stream * obs, tree decl)
 234 {
 235   unsigned int index;
 236   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_VAR_DECL],
 237                          decl, &index);
 238 }
 239
 240 /* Output a type DECL to OBS.  */
 241
 242 void
 243 lto_output_type_decl_index (struct lto_out_decl_state *decl_state,
 244                             struct lto_output_stream * obs, tree decl)
 245 {
 246   unsigned int index;
 247   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_TYPE_DECL],
 248                          decl, &index);
 249 }
 250
 251 /* Output a type REF to OBS.  */
 252
 253 void
 254 lto_output_type_ref_index (struct lto_out_decl_state *decl_state,
 255                            struct lto_output_stream *obs, tree ref)
 256 {
 257   unsigned int index;
 258   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_TYPE],
 259                          ref, &index);
 260 }
 261
 262
 263 /* Create the output block and return it.  */
 264
 265 struct lto_simple_output_block *
 266 lto_create_simple_output_block (enum lto_section_type section_type)
 267 {
 268   struct lto_simple_output_block *ob
 269     = ((struct lto_simple_output_block *)
 270        xcalloc (1, sizeof (struct lto_simple_output_block)));
 271
 272   ob->section_type = section_type;
 273   ob->decl_state = lto_get_out_decl_state ();
 274   ob->main_stream = ((struct lto_output_stream *)
 275                      xcalloc (1, sizeof (struct lto_output_stream)));
 276
 277   return ob;
 278 }
 279
 280
 281 /* Produce a simple section for one of the ipa passes.  */
 282
 283 void
 284 lto_destroy_simple_output_block (struct lto_simple_output_block *ob)
 285 {
 286   char *section_name;
 287   struct lto_simple_header header;
 288
 289   section_name = lto_get_section_name (ob->section_type, NULL, NULL);
 290   lto_begin_section (section_name, !flag_wpa);
 291   free (section_name);
 292
 293   /* Write the header which says how to decode the pieces of the
 294      t.  */
 295   memset (&header, 0, sizeof (struct lto_simple_header));
 296   header.major_version = LTO_major_version;
 297   header.minor_version = LTO_minor_version;
 298   header.main_size = ob->main_stream->total_size;
 299   lto_write_data (&header, sizeof header);
 300
 301   lto_write_stream (ob->main_stream);
 302
 303   /* Put back the assembly section that was there before we started
 304      writing lto info.  */
 305   lto_end_section ();
 306
 307   free (ob->main_stream);
 308   free (ob);
 309 }
 310
 311
 312 /* Return a new lto_out_decl_state. */
 313
 314 struct lto_out_decl_state *
 315 lto_new_out_decl_state (void)
 316 {
 317   struct lto_out_decl_state *state = XCNEW (struct lto_out_decl_state);
 318   int i;
 319
 320   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 321     lto_init_tree_ref_encoder (&state->streams[i]);
 322
 323   return state;
 324 }
 325
 326
 327 /* Delete STATE and components.  */
 328
 329 void
 330 lto_delete_out_decl_state (struct lto_out_decl_state *state)
 331 {
 332   int i;
 333
 334   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 335     lto_destroy_tree_ref_encoder (&state->streams[i]);
 336
 337   free (state);
 338 }
 339
 340
 341 /* Get the currently used lto_out_decl_state structure. */
 342
 343 struct lto_out_decl_state *
 344 lto_get_out_decl_state (void)
 345 {
 346   return decl_state_stack.last ();
 347 }
 348
 349 /* Push STATE to top of out decl stack. */
 350
 351 void
 352 lto_push_out_decl_state (struct lto_out_decl_state *state)
 353 {
 354   decl_state_stack.safe_push (state);
 355 }
 356
 357 /* Pop the currently used out-decl state from top of stack. */
 358
 359 struct lto_out_decl_state *
 360 lto_pop_out_decl_state (void)
 361 {
 362   return decl_state_stack.pop ();
 363 }
 364
 365 /* Record STATE after it has been used in serializing the body of
 366    FN_DECL.  STATE should no longer be used by the caller.  The ownership
 367    of it is taken over from this point.  */
 368
 369 void
 370 lto_record_function_out_decl_state (tree fn_decl,
 371                                     struct lto_out_decl_state *state)
 372 {
 373   int i;
 374
 375   /* Strip all hash tables to save some memory. */
 376   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 377     if (state->streams[i].tree_hash_table)
 378       {
 379         delete state->streams[i].tree_hash_table;
 380         state->streams[i].tree_hash_table = NULL;
 381       }
 382   state->fn_decl = fn_decl;
 383   lto_function_decl_states.safe_push (state);
 384 }