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