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