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