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 /* Lookup NAME in ENCODER.  If NAME is not found, create a new entry in
 334    ENCODER for NAME with the next available index of ENCODER,  then
 335    print the index to OBS.  True is returned if NAME was added to
 336    ENCODER.  The resulting index is stored in THIS_INDEX.
 337
 338    If OBS is NULL, the only action is to add NAME to the encoder. */
 339
 340 bool
 341 lto_output_decl_index (struct lto_output_stream *obs,
 342                        struct lto_tree_ref_encoder *encoder,
 343                        tree name, unsigned int *this_index)
 344 {
 345   void **slot;
 346   struct lto_decl_slot d_slot;
 347   int index;
 348   bool new_entry_p = FALSE;
 349
 350   d_slot.t = name;
 351   slot = htab_find_slot (encoder->tree_hash_table, &d_slot, INSERT);
 352   if (*slot == NULL)
 353     {
 354       struct lto_decl_slot *new_slot
 355         = (struct lto_decl_slot *) xmalloc (sizeof (struct lto_decl_slot));
 356       index = encoder->next_index++;
 357
 358       new_slot->t = name;
 359       new_slot->slot_num = index;
 360       *slot = new_slot;
 361       VEC_safe_push (tree, heap, encoder->trees, name);
 362       new_entry_p = TRUE;
 363     }
 364   else
 365     {
 366       struct lto_decl_slot *old_slot = (struct lto_decl_slot *)*slot;
 367       index = old_slot->slot_num;
 368     }
 369
 370   if (obs)
 371     lto_output_uleb128_stream (obs, index);
 372   *this_index = index;
 373   return new_entry_p;
 374 }
 375
 376 /* Output a field DECL to OBS.  */
 377
 378 void
 379 lto_output_field_decl_index (struct lto_out_decl_state *decl_state,
 380                              struct lto_output_stream * obs, tree decl)
 381 {
 382   unsigned int index;
 383   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_FIELD_DECL],
 384                          decl, &index);
 385 }
 386
 387 /* Output a function DECL to OBS.  */
 388
 389 void
 390 lto_output_fn_decl_index (struct lto_out_decl_state *decl_state,
 391                           struct lto_output_stream * obs, tree decl)
 392 {
 393   unsigned int index;
 394   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_FN_DECL],
 395                          decl, &index);
 396 }
 397
 398 /* Output a namespace DECL to OBS.  */
 399
 400 void
 401 lto_output_namespace_decl_index (struct lto_out_decl_state *decl_state,
 402                                  struct lto_output_stream * obs, tree decl)
 403 {
 404   unsigned int index;
 405   lto_output_decl_index (obs,
 406                          &decl_state->streams[LTO_DECL_STREAM_NAMESPACE_DECL],
 407                          decl, &index);
 408 }
 409
 410 /* Output a static or extern var DECL to OBS.  */
 411
 412 void
 413 lto_output_var_decl_index (struct lto_out_decl_state *decl_state,
 414                            struct lto_output_stream * obs, tree decl)
 415 {
 416   unsigned int index;
 417   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_VAR_DECL],
 418                          decl, &index);
 419 }
 420
 421 /* Output a type DECL to OBS.  */
 422
 423 void
 424 lto_output_type_decl_index (struct lto_out_decl_state *decl_state,
 425                             struct lto_output_stream * obs, tree decl)
 426 {
 427   unsigned int index;
 428   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_TYPE_DECL],
 429                          decl, &index);
 430 }
 431
 432 /* Output a type REF to OBS.  */
 433
 434 void
 435 lto_output_type_ref_index (struct lto_out_decl_state *decl_state,
 436                            struct lto_output_stream *obs, tree ref)
 437 {
 438   unsigned int index;
 439   lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_TYPE],
 440                          ref, &index);
 441 }
 442
 443
 444 /* Create the output block and return it.  */
 445
 446 struct lto_simple_output_block *
 447 lto_create_simple_output_block (enum lto_section_type section_type)
 448 {
 449   struct lto_simple_output_block *ob
 450     = ((struct lto_simple_output_block *)
 451        xcalloc (1, sizeof (struct lto_simple_output_block)));
 452
 453   ob->section_type = section_type;
 454   ob->decl_state = lto_get_out_decl_state ();
 455   ob->main_stream = ((struct lto_output_stream *)
 456                      xcalloc (1, sizeof (struct lto_output_stream)));
 457
 458   return ob;
 459 }
 460
 461
 462 /* Produce a simple section for one of the ipa passes.  */
 463
 464 void
 465 lto_destroy_simple_output_block (struct lto_simple_output_block *ob)
 466 {
 467   char *section_name;
 468   struct lto_simple_header header;
 469   struct lto_output_stream *header_stream;
 470
 471   section_name = lto_get_section_name (ob->section_type, NULL, NULL);
 472   lto_begin_section (section_name, !flag_wpa);
 473   free (section_name);
 474
 475   /* Write the header which says how to decode the pieces of the
 476      t.  */
 477   memset (&header, 0, sizeof (struct lto_simple_header));
 478   header.lto_header.major_version = LTO_major_version;
 479   header.lto_header.minor_version = LTO_minor_version;
 480   header.lto_header.section_type = LTO_section_cgraph;
 481
 482   header.compressed_size = 0;
 483
 484   header.main_size = ob->main_stream->total_size;
 485
 486   header_stream = XCNEW (struct lto_output_stream);
 487   lto_output_data_stream (header_stream, &header, sizeof header);
 488   lto_write_stream (header_stream);
 489   free (header_stream);
 490
 491   lto_write_stream (ob->main_stream);
 492
 493   /* Put back the assembly section that was there before we started
 494      writing lto info.  */
 495   lto_end_section ();
 496
 497   free (ob->main_stream);
 498   free (ob);
 499 }
 500
 501
 502 /* Return a new lto_out_decl_state. */
 503
 504 struct lto_out_decl_state *
 505 lto_new_out_decl_state (void)
 506 {
 507   struct lto_out_decl_state *state = XCNEW (struct lto_out_decl_state);
 508   int i;
 509   htab_hash hash_fn;
 510   htab_eq eq_fn;
 511
 512   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 513     {
 514       if (i == LTO_DECL_STREAM_TYPE)
 515         {
 516           hash_fn = lto_hash_type_slot_node;
 517           eq_fn = lto_eq_type_slot_node;
 518         }
 519       else
 520         {
 521           hash_fn = lto_hash_decl_slot_node;
 522           eq_fn = lto_eq_decl_slot_node;
 523         }
 524       lto_init_tree_ref_encoder (&state->streams[i], hash_fn, eq_fn);
 525     }
 526
 527   return state;
 528 }
 529
 530
 531 /* Delete STATE and components.  */
 532
 533 void
 534 lto_delete_out_decl_state (struct lto_out_decl_state *state)
 535 {
 536   int i;
 537
 538   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 539     lto_destroy_tree_ref_encoder (&state->streams[i]);
 540
 541   free (state);
 542 }
 543
 544
 545 /* Get the currently used lto_out_decl_state structure. */
 546
 547 struct lto_out_decl_state *
 548 lto_get_out_decl_state (void)
 549 {
 550   return VEC_last (lto_out_decl_state_ptr, decl_state_stack);
 551 }
 552
 553 /* Push STATE to top of out decl stack. */
 554
 555 void
 556 lto_push_out_decl_state (struct lto_out_decl_state *state)
 557 {
 558   VEC_safe_push (lto_out_decl_state_ptr, heap, decl_state_stack, state);
 559 }
 560
 561 /* Pop the currently used out-decl state from top of stack. */
 562
 563 struct lto_out_decl_state *
 564 lto_pop_out_decl_state (void)
 565 {
 566   return VEC_pop (lto_out_decl_state_ptr, decl_state_stack);
 567 }
 568
 569 /* Record STATE after it has been used in serializing the body of
 570    FN_DECL.  STATE should no longer be used by the caller.  The ownership
 571    of it is taken over from this point.  */
 572
 573 void
 574 lto_record_function_out_decl_state (tree fn_decl,
 575                                     struct lto_out_decl_state *state)
 576 {
 577   int i;
 578
 579   /* Strip all hash tables to save some memory. */
 580   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
 581     if (state->streams[i].tree_hash_table)
 582       {
 583         htab_delete (state->streams[i].tree_hash_table);
 584         state->streams[i].tree_hash_table = NULL;
 585       }
 586   state->fn_decl = fn_decl;
 587   VEC_safe_push (lto_out_decl_state_ptr, heap, lto_function_decl_states,
 588                  state);
 589 }