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