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