gcc/lto-section-out.c

   1 /* Functions for writing LTO sections.
   2
   3    Copyright (C) 2009, 2010 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 "tree-pass.h"
  34 #include "cgraph.h"
  35 #include "function.h"
  36 #include "ggc.h"
  37 #include "except.h"
  38 #include "vec.h"
  39 #include "pointer-set.h"
  40 #include "bitmap.h"
  41 #include "langhooks.h"
  42 #include "lto-streamer.h"
  43 #include "lto-compress.h"
  44
  45 static VEC(lto_out_decl_state_ptr, heap) *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, heap) *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 static void
 198 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 a character to the output block.  */
 238
 239 void
 240 lto_output_1_stream (struct lto_output_stream *obs, char c)
 241 {
 242   /* No space left.  */
 243   if (obs->left_in_block == 0)
 244     append_block (obs);
 245
 246   /* Write the actual character.  */
 247   *obs->current_pointer = c;
 248   obs->current_pointer++;
 249   obs->total_size++;
 250   obs->left_in_block--;
 251 }
 252
 253
 254 /* Write raw DATA of length LEN to the output block OB.  */
 255
 256 void
 257 lto_output_data_stream (struct lto_output_stream *obs, const void *data,
 258                         size_t len)
 259 {
 260   while (len)
 261     {
 262       size_t copy;
 263
 264       /* No space left.  */
 265       if (obs->left_in_block == 0)
 266         append_block (obs);
 267
 268       /* Determine how many bytes to copy in this loop.  */
 269       if (len <= obs->left_in_block)
 270         copy = len;
 271       else
 272         copy = obs->left_in_block;
 273
 274       /* Copy the data and do bookkeeping.  */
 275       memcpy (obs->current_pointer, data, copy);
 276       obs->current_pointer += copy;
 277       obs->total_size += copy;
 278       obs->left_in_block -= copy;
 279       data = (const char *) data + copy;
 280       len -= copy;
 281     }
 282 }
 283
 284
 285 /* Output an unsigned LEB128 quantity to OBS.  */
 286
 287 void
 288 lto_output_uleb128_stream (struct lto_output_stream *obs,
 289                            unsigned HOST_WIDE_INT work)
 290 {
 291   do
 292     {
 293       unsigned int byte = (work & 0x7f);
 294       work >>= 7;
 295       if (work != 0)
 296         /* More bytes to follow.  */
 297         byte |= 0x80;
 298
 299       lto_output_1_stream (obs, byte);
 300     }
 301   while (work != 0);
 302 }
 303
 304 /* Identical to output_uleb128_stream above except using unsigned
 305    HOST_WIDEST_INT type.  For efficiency on host where unsigned HOST_WIDEST_INT
 306    is not native, we only use this if we know that HOST_WIDE_INT is not wide
 307    enough.  */
 308
 309 void
 310 lto_output_widest_uint_uleb128_stream (struct lto_output_stream *obs,
 311                                        unsigned HOST_WIDEST_INT work)
 312 {
 313   do
 314     {
 315       unsigned int byte = (work & 0x7f);
 316       work >>= 7;
 317       if (work != 0)
 318         /* More bytes to follow.  */
 319         byte |= 0x80;
 320
 321       lto_output_1_stream (obs, byte);
 322     }
 323   while (work != 0);
 324 }
 325
 326
 327 /* Output a signed LEB128 quantity.  */
 328
 329 void
 330 lto_output_sleb128_stream (struct lto_output_stream *obs, HOST_WIDE_INT work)
 331 {
 332   int more, byte;
 333
 334   do
 335     {
 336       byte = (work & 0x7f);
 337       /* arithmetic shift */
 338       work >>= 7;
 339       more = !((work == 0 && (byte & 0x40) == 0)
 340                || (work == -1 && (byte & 0x40) != 0));
 341       if (more)
 342         byte |= 0x80;
 343
 344       lto_output_1_stream (obs, byte);
 345     }
 346   while (more);
 347 }
 348
 349
 350 /* Lookup NAME in ENCODER.  If NAME is not found, create a new entry in
 351    ENCODER for NAME with the next available index of ENCODER,  then
 352    print the index to OBS.  True is returned if NAME was added to
 353    ENCODER.  The resulting index is stored in THIS_INDEX.
 354
 355    If OBS is NULL, the only action is to add NAME to the encoder. */
 356
 357 bool
 358 lto_output_decl_index (struct lto_output_stream *obs,
 359                        struct lto_tree_ref_encoder *encoder,
 360                        tree name, unsigned int *this_index)
 361 {
 362   void **slot;
 363   struct lto_decl_slot d_slot;
 364   int index;
 365   bool new_entry_p = FALSE;
 366
 367   d_slot.t = name;
 368   slot = htab_find_slot (encoder->tree_hash_table, &d_slot, INSERT);
 369   if (*slot == NULL)
 370     {
 371       struct lto_decl_slot *new_slot
 372         = (struct lto_decl_slot *) xmalloc (sizeof (struct lto_decl_slot));
 373       index = encoder->next_index++;
 374
 375       new_slot->t = name;
 376       new_slot->slot_num = index;
 377       *slot = new_slot;
 378       VEC_safe_push (tree, heap, encoder->trees, name);
 379       new_entry_p = TRUE;
 380     }
 381   else
 382     {
 383       struct lto_decl_slot *old_slot = (struct lto_decl_slot *)*slot;
 384       index = old_slot->slot_num;
 385     }
 386
 387   if (obs)
 388     lto_output_uleb128_stream (obs, index);
 389   *this_index = index;
 390   return new_entry_p;
 391 }
 392
 393 /* Output a field DECL to OBS.  */
 394
 395 void
 396 lto_output_field_decl_index (struct lto_out_decl_state *decl_state,
 397                              struct lto_output_stream * obs, tree decl)
 398 {
 399   unsigned int index;
 400   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_FIELD_DECL],
 401                          decl, &index);
 402 }
 403
 404 /* Output a function DECL to OBS.  */
 405
 406 void
 407 lto_output_fn_decl_index (struct lto_out_decl_state *decl_state,
 408                           struct lto_output_stream * obs, tree decl)
 409 {
 410   unsigned int index;
 411   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_FN_DECL],
 412                          decl, &index);
 413 }
 414
 415 /* Output a namespace DECL to OBS.  */
 416
 417 void
 418 lto_output_namespace_decl_index (struct lto_out_decl_state *decl_state,
 419                                  struct lto_output_stream * obs, tree decl)
 420 {
 421   unsigned int index;
 422   lto_output_decl_index (obs,
 423                          &decl_state->streams[LTO_DECL_STREAM_NAMESPACE_DECL],
 424                          decl, &index);
 425 }
 426
 427 /* Output a static or extern var DECL to OBS.  */
 428
 429 void
 430 lto_output_var_decl_index (struct lto_out_decl_state *decl_state,
 431                            struct lto_output_stream * obs, tree decl)
 432 {
 433   unsigned int index;
 434   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_VAR_DECL],
 435                          decl, &index);
 436 }
 437
 438 /* Output a type DECL to OBS.  */
 439
 440 void
 441 lto_output_type_decl_index (struct lto_out_decl_state *decl_state,
 442                             struct lto_output_stream * obs, tree decl)
 443 {
 444   unsigned int index;
 445   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_TYPE_DECL],
 446                          decl, &index);
 447 }
 448
 449 /* Output a type REF to OBS.  */
 450
 451 void
 452 lto_output_type_ref_index (struct lto_out_decl_state *decl_state,
 453                            struct lto_output_stream *obs, tree ref)
 454 {
 455   unsigned int index;
 456   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_TYPE],
 457                          ref, &index);
 458 }
 459
 460
 461 /* Create the output block and return it.  */
 462
 463 struct lto_simple_output_block *
 464 lto_create_simple_output_block (enum lto_section_type section_type)
 465 {
 466   struct lto_simple_output_block *ob
 467     = ((struct lto_simple_output_block *)
 468        xcalloc (1, sizeof (struct lto_simple_output_block)));
 469
 470   ob->section_type = section_type;
 471   ob->decl_state = lto_get_out_decl_state ();
 472   ob->main_stream = ((struct lto_output_stream *)
 473                      xcalloc (1, sizeof (struct lto_output_stream)));
 474
 475   return ob;
 476 }
 477
 478
 479 /* Produce a simple section for one of the ipa passes.  */
 480
 481 void
 482 lto_destroy_simple_output_block (struct lto_simple_output_block *ob)
 483 {
 484   char *section_name;
 485   struct lto_simple_header header;
 486   struct lto_output_stream *header_stream;
 487
 488   section_name = lto_get_section_name (ob->section_type, NULL, NULL);
 489   lto_begin_section (section_name, !flag_wpa);
 490   free (section_name);
 491
 492   /* Write the header which says how to decode the pieces of the
 493      t.  */
 494   memset (&header, 0, sizeof (struct lto_simple_header));
 495   header.lto_header.major_version = LTO_major_version;
 496   header.lto_header.minor_version = LTO_minor_version;
 497   header.lto_header.section_type = LTO_section_cgraph;
 498
 499   header.compressed_size = 0;
 500
 501   header.main_size = ob->main_stream->total_size;
 502
 503   header_stream = XCNEW (struct lto_output_stream);
 504   lto_output_data_stream (header_stream, &header, sizeof header);
 505   lto_write_stream (header_stream);
 506   free (header_stream);
 507
 508   lto_write_stream (ob->main_stream);
 509
 510   /* Put back the assembly section that was there before we started
 511      writing lto info.  */
 512   lto_end_section ();
 513
 514   free (ob->main_stream);
 515   free (ob);
 516 }
 517
 518
 519 /* Return a new lto_out_decl_state. */
 520
 521 struct lto_out_decl_state *
 522 lto_new_out_decl_state (void)
 523 {
 524   struct lto_out_decl_state *state = XCNEW (struct lto_out_decl_state);
 525   int i;
 526   htab_hash hash_fn;
 527   htab_eq eq_fn;
 528
 529   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 530     {
 531       if (i == LTO_DECL_STREAM_TYPE)
 532         {
 533           hash_fn = lto_hash_type_slot_node;
 534           eq_fn = lto_eq_type_slot_node;
 535         }
 536       else
 537         {
 538           hash_fn = lto_hash_decl_slot_node;
 539           eq_fn = lto_eq_decl_slot_node;
 540         }
 541       lto_init_tree_ref_encoder (&state->streams[i], hash_fn, eq_fn);
 542     }
 543
 544   return state;
 545 }
 546
 547
 548 /* Delete STATE and components.  */
 549
 550 void
 551 lto_delete_out_decl_state (struct lto_out_decl_state *state)
 552 {
 553   int i;
 554
 555   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 556     lto_destroy_tree_ref_encoder (&state->streams[i]);
 557
 558   free (state);
 559 }
 560
 561
 562 /* Get the currently used lto_out_decl_state structure. */
 563
 564 struct lto_out_decl_state *
 565 lto_get_out_decl_state (void)
 566 {
 567   return VEC_last (lto_out_decl_state_ptr, decl_state_stack);
 568 }
 569
 570 /* Push STATE to top of out decl stack. */
 571
 572 void
 573 lto_push_out_decl_state (struct lto_out_decl_state *state)
 574 {
 575   VEC_safe_push (lto_out_decl_state_ptr, heap, decl_state_stack, state);
 576 }
 577
 578 /* Pop the currently used out-decl state from top of stack. */
 579
 580 struct lto_out_decl_state *
 581 lto_pop_out_decl_state (void)
 582 {
 583   return VEC_pop (lto_out_decl_state_ptr, decl_state_stack);
 584 }
 585
 586 /* Record STATE after it has been used in serializing the body of
 587    FN_DECL.  STATE should no longer be used by the caller.  The ownership
 588    of it is taken over from this point.  */
 589
 590 void
 591 lto_record_function_out_decl_state (tree fn_decl,
 592                                     struct lto_out_decl_state *state)
 593 {
 594   int i;
 595
 596   /* Strip all hash tables to save some memory. */
 597   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 598     if (state->streams[i].tree_hash_table)
 599       {
 600         htab_delete (state->streams[i].tree_hash_table);
 601         state->streams[i].tree_hash_table = NULL;
 602       }
 603   state->fn_decl = fn_decl;
 604   VEC_safe_push (lto_out_decl_state_ptr, heap, lto_function_decl_states,
 605                  state);
 606 }