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