gcc/lto-section-out.c

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