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