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