gcc/lto-section-out.c

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