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