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