gcc/lto-streamer-in.c

   1 /* Read the GIMPLE representation from a file stream.
   2
   3    Copyright 2009, 2010 Free Software Foundation, Inc.
   4    Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
   5    Re-implemented by Diego Novillo <dnovillo@google.com>
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 3, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "toplev.h"
  28 #include "tree.h"
  29 #include "expr.h"
  30 #include "flags.h"
  31 #include "params.h"
  32 #include "input.h"
  33 #include "hashtab.h"
  34 #include "basic-block.h"
  35 #include "tree-flow.h"
  36 #include "tree-pass.h"
  37 #include "cgraph.h"
  38 #include "function.h"
  39 #include "ggc.h"
  40 #include "diagnostic.h"
  41 #include "libfuncs.h"
  42 #include "except.h"
  43 #include "debug.h"
  44 #include "vec.h"
  45 #include "timevar.h"
  46 #include "output.h"
  47 #include "ipa-utils.h"
  48 #include "data-streamer.h"
  49 #include "gimple-streamer.h"
  50 #include "lto-streamer.h"
  51 #include "tree-streamer.h"
  52 #include "tree-pass.h"
  53 #include "streamer-hooks.h"
  54
  55 /* The table to hold the file names.  */
  56 static htab_t file_name_hash_table;
  57
  58
  59 /* Check that tag ACTUAL has one of the given values.  NUM_TAGS is the
  60    number of valid tag values to check.  */
  61
  62 void
  63 lto_tag_check_set (enum LTO_tags actual, int ntags, ...)
  64 {
  65   va_list ap;
  66   int i;
  67
  68   va_start (ap, ntags);
  69   for (i = 0; i < ntags; i++)
  70     if ((unsigned) actual == va_arg (ap, unsigned))
  71       {
  72         va_end (ap);
  73         return;
  74       }
  75
  76   va_end (ap);
  77   internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual));
  78 }
  79
  80
  81 /* Read LENGTH bytes from STREAM to ADDR.  */
  82
  83 void
  84 lto_input_data_block (struct lto_input_block *ib, void *addr, size_t length)
  85 {
  86   size_t i;
  87   unsigned char *const buffer = (unsigned char *const) addr;
  88
  89   for (i = 0; i < length; i++)
  90     buffer[i] = streamer_read_uchar (ib);
  91 }
  92
  93
  94 /* Lookup STRING in file_name_hash_table.  If found, return the existing
  95    string, otherwise insert STRING as the canonical version.  */
  96
  97 static const char *
  98 canon_file_name (const char *string)
  99 {
 100   void **slot;
 101   struct string_slot s_slot;
 102   size_t len = strlen (string);
 103
 104   s_slot.s = string;
 105   s_slot.len = len;
 106
 107   slot = htab_find_slot (file_name_hash_table, &s_slot, INSERT);
 108   if (*slot == NULL)
 109     {
 110       char *saved_string;
 111       struct string_slot *new_slot;
 112
 113       saved_string = (char *) xmalloc (len + 1);
 114       new_slot = XCNEW (struct string_slot);
 115       memcpy (saved_string, string, len + 1);
 116       new_slot->s = saved_string;
 117       new_slot->len = len;
 118       *slot = new_slot;
 119       return saved_string;
 120     }
 121   else
 122     {
 123       struct string_slot *old_slot = (struct string_slot *) *slot;
 124       return old_slot->s;
 125     }
 126 }
 127
 128
 129 /* Clear the line info stored in DATA_IN.  */
 130
 131 static void
 132 clear_line_info (struct data_in *data_in)
 133 {
 134   if (data_in->current_file)
 135     linemap_add (line_table, LC_LEAVE, false, NULL, 0);
 136   data_in->current_file = NULL;
 137   data_in->current_line = 0;
 138   data_in->current_col = 0;
 139 }
 140
 141
 142 /* Read a location bitpack from input block IB.  */
 143
 144 static location_t
 145 lto_input_location_bitpack (struct data_in *data_in, struct bitpack_d *bp)
 146 {
 147   bool file_change, line_change, column_change;
 148   unsigned len;
 149   bool prev_file = data_in->current_file != NULL;
 150
 151   if (bp_unpack_value (bp, 1))
 152     return UNKNOWN_LOCATION;
 153
 154   file_change = bp_unpack_value (bp, 1);
 155   if (file_change)
 156     data_in->current_file = canon_file_name
 157                               (string_for_index (data_in,
 158                                                  bp_unpack_var_len_unsigned (bp),
 159                                                  &len));
 160
 161   line_change = bp_unpack_value (bp, 1);
 162   if (line_change)
 163     data_in->current_line = bp_unpack_var_len_unsigned (bp);
 164
 165   column_change = bp_unpack_value (bp, 1);
 166   if (column_change)
 167     data_in->current_col = bp_unpack_var_len_unsigned (bp);
 168
 169   if (file_change)
 170     {
 171       if (prev_file)
 172         linemap_add (line_table, LC_LEAVE, false, NULL, 0);
 173
 174       linemap_add (line_table, LC_ENTER, false, data_in->current_file,
 175                    data_in->current_line);
 176     }
 177   else if (line_change)
 178     linemap_line_start (line_table, data_in->current_line, data_in->current_col);
 179
 180   return linemap_position_for_column (line_table, data_in->current_col);
 181 }
 182
 183
 184 /* Read a location from input block IB.
 185    If the input_location streamer hook exists, call it.
 186    Otherwise, proceed with reading the location from the
 187    expanded location bitpack.  */
 188
 189 location_t
 190 lto_input_location (struct lto_input_block *ib, struct data_in *data_in)
 191 {
 192   if (streamer_hooks.input_location)
 193     return streamer_hooks.input_location (ib, data_in);
 194   else
 195     {
 196       struct bitpack_d bp;
 197
 198       bp = streamer_read_bitpack (ib);
 199       return lto_input_location_bitpack (data_in, &bp);
 200     }
 201 }
 202
 203
 204 /* Read a reference to a tree node from DATA_IN using input block IB.
 205    TAG is the expected node that should be found in IB, if TAG belongs
 206    to one of the indexable trees, expect to read a reference index to
 207    be looked up in one of the symbol tables, otherwise read the pysical
 208    representation of the tree using stream_read_tree.  FN is the
 209    function scope for the read tree.  */
 210
 211 tree
 212 lto_input_tree_ref (struct lto_input_block *ib, struct data_in *data_in,
 213                     struct function *fn, enum LTO_tags tag)
 214 {
 215   unsigned HOST_WIDE_INT ix_u;
 216   tree result = NULL_TREE;
 217
 218   lto_tag_check_range (tag, LTO_field_decl_ref, LTO_global_decl_ref);
 219
 220   switch (tag)
 221     {
 222     case LTO_type_ref:
 223       ix_u = streamer_read_uhwi (ib);
 224       result = lto_file_decl_data_get_type (data_in->file_data, ix_u);
 225       break;
 226
 227     case LTO_ssa_name_ref:
 228       ix_u = streamer_read_uhwi (ib);
 229       result = VEC_index (tree, SSANAMES (fn), ix_u);
 230       break;
 231
 232     case LTO_field_decl_ref:
 233       ix_u = streamer_read_uhwi (ib);
 234       result = lto_file_decl_data_get_field_decl (data_in->file_data, ix_u);
 235       break;
 236
 237     case LTO_function_decl_ref:
 238       ix_u = streamer_read_uhwi (ib);
 239       result = lto_file_decl_data_get_fn_decl (data_in->file_data, ix_u);
 240       break;
 241
 242     case LTO_type_decl_ref:
 243       ix_u = streamer_read_uhwi (ib);
 244       result = lto_file_decl_data_get_type_decl (data_in->file_data, ix_u);
 245       break;
 246
 247     case LTO_namespace_decl_ref:
 248       ix_u = streamer_read_uhwi (ib);
 249       result = lto_file_decl_data_get_namespace_decl (data_in->file_data, ix_u);
 250       break;
 251
 252     case LTO_global_decl_ref:
 253     case LTO_result_decl_ref:
 254     case LTO_const_decl_ref:
 255     case LTO_imported_decl_ref:
 256     case LTO_label_decl_ref:
 257     case LTO_translation_unit_decl_ref:
 258       ix_u = streamer_read_uhwi (ib);
 259       result = lto_file_decl_data_get_var_decl (data_in->file_data, ix_u);
 260       break;
 261
 262     default:
 263       gcc_unreachable ();
 264     }
 265
 266   gcc_assert (result);
 267
 268   return result;
 269 }
 270
 271
 272 /* Read and return a double-linked list of catch handlers from input
 273    block IB, using descriptors in DATA_IN.  */
 274
 275 static struct eh_catch_d *
 276 lto_input_eh_catch_list (struct lto_input_block *ib, struct data_in *data_in,
 277                          eh_catch *last_p)
 278 {
 279   eh_catch first;
 280   enum LTO_tags tag;
 281
 282   *last_p = first = NULL;
 283   tag = streamer_read_record_start (ib);
 284   while (tag)
 285     {
 286       tree list;
 287       eh_catch n;
 288
 289       lto_tag_check_range (tag, LTO_eh_catch, LTO_eh_catch);
 290
 291       /* Read the catch node.  */
 292       n = ggc_alloc_cleared_eh_catch_d ();
 293       n->type_list = stream_read_tree (ib, data_in);
 294       n->filter_list = stream_read_tree (ib, data_in);
 295       n->label = stream_read_tree (ib, data_in);
 296
 297       /* Register all the types in N->FILTER_LIST.  */
 298       for (list = n->filter_list; list; list = TREE_CHAIN (list))
 299         add_type_for_runtime (TREE_VALUE (list));
 300
 301       /* Chain N to the end of the list.  */
 302       if (*last_p)
 303         (*last_p)->next_catch = n;
 304       n->prev_catch = *last_p;
 305       *last_p = n;
 306
 307       /* Set the head of the list the first time through the loop.  */
 308       if (first == NULL)
 309         first = n;
 310
 311       tag = streamer_read_record_start (ib);
 312     }
 313
 314   return first;
 315 }
 316
 317
 318 /* Read and return EH region IX from input block IB, using descriptors
 319    in DATA_IN.  */
 320
 321 static eh_region
 322 input_eh_region (struct lto_input_block *ib, struct data_in *data_in, int ix)
 323 {
 324   enum LTO_tags tag;
 325   eh_region r;
 326
 327   /* Read the region header.  */
 328   tag = streamer_read_record_start (ib);
 329   if (tag == LTO_null)
 330     return NULL;
 331
 332   r = ggc_alloc_cleared_eh_region_d ();
 333   r->index = streamer_read_hwi (ib);
 334
 335   gcc_assert (r->index == ix);
 336
 337   /* Read all the region pointers as region numbers.  We'll fix up
 338      the pointers once the whole array has been read.  */
 339   r->outer = (eh_region) (intptr_t) streamer_read_hwi (ib);
 340   r->inner = (eh_region) (intptr_t) streamer_read_hwi (ib);
 341   r->next_peer = (eh_region) (intptr_t) streamer_read_hwi (ib);
 342
 343   switch (tag)
 344     {
 345       case LTO_ert_cleanup:
 346         r->type = ERT_CLEANUP;
 347         break;
 348
 349       case LTO_ert_try:
 350         {
 351           struct eh_catch_d *last_catch;
 352           r->type = ERT_TRY;
 353           r->u.eh_try.first_catch = lto_input_eh_catch_list (ib, data_in,
 354                                                              &last_catch);
 355           r->u.eh_try.last_catch = last_catch;
 356           break;
 357         }
 358
 359       case LTO_ert_allowed_exceptions:
 360         {
 361           tree l;
 362
 363           r->type = ERT_ALLOWED_EXCEPTIONS;
 364           r->u.allowed.type_list = stream_read_tree (ib, data_in);
 365           r->u.allowed.label = stream_read_tree (ib, data_in);
 366           r->u.allowed.filter = streamer_read_uhwi (ib);
 367
 368           for (l = r->u.allowed.type_list; l ; l = TREE_CHAIN (l))
 369             add_type_for_runtime (TREE_VALUE (l));
 370         }
 371         break;
 372
 373       case LTO_ert_must_not_throw:
 374         r->type = ERT_MUST_NOT_THROW;
 375         r->u.must_not_throw.failure_decl = stream_read_tree (ib, data_in);
 376         r->u.must_not_throw.failure_loc = lto_input_location (ib, data_in);
 377         break;
 378
 379       default:
 380         gcc_unreachable ();
 381     }
 382
 383   r->landing_pads = (eh_landing_pad) (intptr_t) streamer_read_hwi (ib);
 384
 385   return r;
 386 }
 387
 388
 389 /* Read and return EH landing pad IX from input block IB, using descriptors
 390    in DATA_IN.  */
 391
 392 static eh_landing_pad
 393 input_eh_lp (struct lto_input_block *ib, struct data_in *data_in, int ix)
 394 {
 395   enum LTO_tags tag;
 396   eh_landing_pad lp;
 397
 398   /* Read the landing pad header.  */
 399   tag = streamer_read_record_start (ib);
 400   if (tag == LTO_null)
 401     return NULL;
 402
 403   lto_tag_check_range (tag, LTO_eh_landing_pad, LTO_eh_landing_pad);
 404
 405   lp = ggc_alloc_cleared_eh_landing_pad_d ();
 406   lp->index = streamer_read_hwi (ib);
 407   gcc_assert (lp->index == ix);
 408   lp->next_lp = (eh_landing_pad) (intptr_t) streamer_read_hwi (ib);
 409   lp->region = (eh_region) (intptr_t) streamer_read_hwi (ib);
 410   lp->post_landing_pad = stream_read_tree (ib, data_in);
 411
 412   return lp;
 413 }
 414
 415
 416 /* After reading the EH regions, pointers to peer and children regions
 417    are region numbers.  This converts all these region numbers into
 418    real pointers into the rematerialized regions for FN.  ROOT_REGION
 419    is the region number for the root EH region in FN.  */
 420
 421 static void
 422 fixup_eh_region_pointers (struct function *fn, HOST_WIDE_INT root_region)
 423 {
 424   unsigned i;
 425   VEC(eh_region,gc) *eh_array = fn->eh->region_array;
 426   VEC(eh_landing_pad,gc) *lp_array = fn->eh->lp_array;
 427   eh_region r;
 428   eh_landing_pad lp;
 429
 430   gcc_assert (eh_array && lp_array);
 431
 432   gcc_assert (root_region >= 0);
 433   fn->eh->region_tree = VEC_index (eh_region, eh_array, root_region);
 434
 435 #define FIXUP_EH_REGION(r) (r) = VEC_index (eh_region, eh_array, \
 436                                             (HOST_WIDE_INT) (intptr_t) (r))
 437 #define FIXUP_EH_LP(p) (p) = VEC_index (eh_landing_pad, lp_array, \
 438                                         (HOST_WIDE_INT) (intptr_t) (p))
 439
 440   /* Convert all the index numbers stored in pointer fields into
 441      pointers to the corresponding slots in the EH region array.  */
 442   FOR_EACH_VEC_ELT (eh_region, eh_array, i, r)
 443     {
 444       /* The array may contain NULL regions.  */
 445       if (r == NULL)
 446         continue;
 447
 448       gcc_assert (i == (unsigned) r->index);
 449       FIXUP_EH_REGION (r->outer);
 450       FIXUP_EH_REGION (r->inner);
 451       FIXUP_EH_REGION (r->next_peer);
 452       FIXUP_EH_LP (r->landing_pads);
 453     }
 454
 455   /* Convert all the index numbers stored in pointer fields into
 456      pointers to the corresponding slots in the EH landing pad array.  */
 457   FOR_EACH_VEC_ELT (eh_landing_pad, lp_array, i, lp)
 458     {
 459       /* The array may contain NULL landing pads.  */
 460       if (lp == NULL)
 461         continue;
 462
 463       gcc_assert (i == (unsigned) lp->index);
 464       FIXUP_EH_LP (lp->next_lp);
 465       FIXUP_EH_REGION (lp->region);
 466     }
 467
 468 #undef FIXUP_EH_REGION
 469 #undef FIXUP_EH_LP
 470 }
 471
 472
 473 /* Initialize EH support.  */
 474
 475 void
 476 lto_init_eh (void)
 477 {
 478   static bool eh_initialized_p = false;
 479
 480   if (eh_initialized_p)
 481     return;
 482
 483   /* Contrary to most other FEs, we only initialize EH support when at
 484      least one of the files in the set contains exception regions in
 485      it.  Since this happens much later than the call to init_eh in
 486      lang_dependent_init, we have to set flag_exceptions and call
 487      init_eh again to initialize the EH tables.  */
 488   flag_exceptions = 1;
 489   init_eh ();
 490
 491   eh_initialized_p = true;
 492 }
 493
 494
 495 /* Read the exception table for FN from IB using the data descriptors
 496    in DATA_IN.  */
 497
 498 static void
 499 input_eh_regions (struct lto_input_block *ib, struct data_in *data_in,
 500                   struct function *fn)
 501 {
 502   HOST_WIDE_INT i, root_region, len;
 503   enum LTO_tags tag;
 504
 505   tag = streamer_read_record_start (ib);
 506   if (tag == LTO_null)
 507     return;
 508
 509   lto_tag_check_range (tag, LTO_eh_table, LTO_eh_table);
 510
 511   /* If the file contains EH regions, then it was compiled with
 512      -fexceptions.  In that case, initialize the backend EH
 513      machinery.  */
 514   lto_init_eh ();
 515
 516   gcc_assert (fn->eh);
 517
 518   root_region = streamer_read_hwi (ib);
 519   gcc_assert (root_region == (int) root_region);
 520
 521   /* Read the EH region array.  */
 522   len = streamer_read_hwi (ib);
 523   gcc_assert (len == (int) len);
 524   if (len > 0)
 525     {
 526       VEC_safe_grow (eh_region, gc, fn->eh->region_array, len);
 527       for (i = 0; i < len; i++)
 528         {
 529           eh_region r = input_eh_region (ib, data_in, i);
 530           VEC_replace (eh_region, fn->eh->region_array, i, r);
 531         }
 532     }
 533
 534   /* Read the landing pads.  */
 535   len = streamer_read_hwi (ib);
 536   gcc_assert (len == (int) len);
 537   if (len > 0)
 538     {
 539       VEC_safe_grow (eh_landing_pad, gc, fn->eh->lp_array, len);
 540       for (i = 0; i < len; i++)
 541         {
 542           eh_landing_pad lp = input_eh_lp (ib, data_in, i);
 543           VEC_replace (eh_landing_pad, fn->eh->lp_array, i, lp);
 544         }
 545     }
 546
 547   /* Read the runtime type data.  */
 548   len = streamer_read_hwi (ib);
 549   gcc_assert (len == (int) len);
 550   if (len > 0)
 551     {
 552       VEC_safe_grow (tree, gc, fn->eh->ttype_data, len);
 553       for (i = 0; i < len; i++)
 554         {
 555           tree ttype = stream_read_tree (ib, data_in);
 556           VEC_replace (tree, fn->eh->ttype_data, i, ttype);
 557         }
 558     }
 559
 560   /* Read the table of action chains.  */
 561   len = streamer_read_hwi (ib);
 562   gcc_assert (len == (int) len);
 563   if (len > 0)
 564     {
 565       if (targetm.arm_eabi_unwinder)
 566         {
 567           VEC_safe_grow (tree, gc, fn->eh->ehspec_data.arm_eabi, len);
 568           for (i = 0; i < len; i++)
 569             {
 570               tree t = stream_read_tree (ib, data_in);
 571               VEC_replace (tree, fn->eh->ehspec_data.arm_eabi, i, t);
 572             }
 573         }
 574       else
 575         {
 576           VEC_safe_grow (uchar, gc, fn->eh->ehspec_data.other, len);
 577           for (i = 0; i < len; i++)
 578             {
 579               uchar c = streamer_read_uchar (ib);
 580               VEC_replace (uchar, fn->eh->ehspec_data.other, i, c);
 581             }
 582         }
 583     }
 584
 585   /* Reconstruct the EH region tree by fixing up the peer/children
 586      pointers.  */
 587   fixup_eh_region_pointers (fn, root_region);
 588
 589   tag = streamer_read_record_start (ib);
 590   lto_tag_check_range (tag, LTO_null, LTO_null);
 591 }
 592
 593
 594 /* Make a new basic block with index INDEX in function FN.  */
 595
 596 static basic_block
 597 make_new_block (struct function *fn, unsigned int index)
 598 {
 599   basic_block bb = alloc_block ();
 600   bb->index = index;
 601   SET_BASIC_BLOCK_FOR_FUNCTION (fn, index, bb);
 602   bb->il.gimple = ggc_alloc_cleared_gimple_bb_info ();
 603   n_basic_blocks_for_function (fn)++;
 604   bb->flags = 0;
 605   set_bb_seq (bb, gimple_seq_alloc ());
 606   return bb;
 607 }
 608
 609
 610 /* Read the CFG for function FN from input block IB.  */
 611
 612 static void
 613 input_cfg (struct lto_input_block *ib, struct function *fn,
 614            int count_materialization_scale)
 615 {
 616   unsigned int bb_count;
 617   basic_block p_bb;
 618   unsigned int i;
 619   int index;
 620
 621   init_empty_tree_cfg_for_function (fn);
 622   init_ssa_operands ();
 623
 624   profile_status_for_function (fn) = streamer_read_enum (ib, profile_status_d,
 625                                                          PROFILE_LAST);
 626
 627   bb_count = streamer_read_uhwi (ib);
 628
 629   last_basic_block_for_function (fn) = bb_count;
 630   if (bb_count > VEC_length (basic_block, basic_block_info_for_function (fn)))
 631     VEC_safe_grow_cleared (basic_block, gc,
 632                            basic_block_info_for_function (fn), bb_count);
 633
 634   if (bb_count > VEC_length (basic_block, label_to_block_map_for_function (fn)))
 635     VEC_safe_grow_cleared (basic_block, gc,
 636                            label_to_block_map_for_function (fn), bb_count);
 637
 638   index = streamer_read_hwi (ib);
 639   while (index != -1)
 640     {
 641       basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
 642       unsigned int edge_count;
 643
 644       if (bb == NULL)
 645         bb = make_new_block (fn, index);
 646
 647       edge_count = streamer_read_uhwi (ib);
 648
 649       /* Connect up the CFG.  */
 650       for (i = 0; i < edge_count; i++)
 651         {
 652           unsigned int dest_index;
 653           unsigned int edge_flags;
 654           basic_block dest;
 655           int probability;
 656           gcov_type count;
 657           edge e;
 658
 659           dest_index = streamer_read_uhwi (ib);
 660           probability = (int) streamer_read_hwi (ib);
 661           count = ((gcov_type) streamer_read_hwi (ib) * count_materialization_scale
 662                    + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE;
 663           edge_flags = streamer_read_uhwi (ib);
 664
 665           dest = BASIC_BLOCK_FOR_FUNCTION (fn, dest_index);
 666
 667           if (dest == NULL)
 668             dest = make_new_block (fn, dest_index);
 669
 670           e = make_edge (bb, dest, edge_flags);
 671           e->probability = probability;
 672           e->count = count;
 673         }
 674
 675       index = streamer_read_hwi (ib);
 676     }
 677
 678   p_bb = ENTRY_BLOCK_PTR_FOR_FUNCTION(fn);
 679   index = streamer_read_hwi (ib);
 680   while (index != -1)
 681     {
 682       basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
 683       bb->prev_bb = p_bb;
 684       p_bb->next_bb = bb;
 685       p_bb = bb;
 686       index = streamer_read_hwi (ib);
 687     }
 688 }
 689
 690
 691 /* Read the SSA names array for function FN from DATA_IN using input
 692    block IB.  */
 693
 694 static void
 695 input_ssa_names (struct lto_input_block *ib, struct data_in *data_in,
 696                  struct function *fn)
 697 {
 698   unsigned int i, size;
 699
 700   size = streamer_read_uhwi (ib);
 701   init_ssanames (fn, size);
 702
 703   i = streamer_read_uhwi (ib);
 704   while (i)
 705     {
 706       tree ssa_name, name;
 707       bool is_default_def;
 708
 709       /* Skip over the elements that had been freed.  */
 710       while (VEC_length (tree, SSANAMES (fn)) < i)
 711         VEC_quick_push (tree, SSANAMES (fn), NULL_TREE);
 712
 713       is_default_def = (streamer_read_uchar (ib) != 0);
 714       name = stream_read_tree (ib, data_in);
 715       ssa_name = make_ssa_name_fn (fn, name, gimple_build_nop ());
 716
 717       if (is_default_def)
 718         set_default_def (SSA_NAME_VAR (ssa_name), ssa_name);
 719
 720       i = streamer_read_uhwi (ib);
 721     }
 722 }
 723
 724
 725 /* Go through all NODE edges and fixup call_stmt pointers
 726    so they point to STMTS.  */
 727
 728 static void
 729 fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple *stmts)
 730 {
 731   struct cgraph_edge *cedge;
 732   for (cedge = node->callees; cedge; cedge = cedge->next_callee)
 733     cedge->call_stmt = stmts[cedge->lto_stmt_uid];
 734   for (cedge = node->indirect_calls; cedge; cedge = cedge->next_callee)
 735     cedge->call_stmt = stmts[cedge->lto_stmt_uid];
 736 }
 737
 738 /* Fixup call_stmt pointers in NODE and all clones.  */
 739
 740 static void
 741 fixup_call_stmt_edges (struct cgraph_node *orig, gimple *stmts)
 742 {
 743   struct cgraph_node *node;
 744
 745   while (orig->clone_of)
 746     orig = orig->clone_of;
 747
 748   fixup_call_stmt_edges_1 (orig, stmts);
 749   if (orig->clones)
 750     for (node = orig->clones; node != orig;)
 751       {
 752         fixup_call_stmt_edges_1 (node, stmts);
 753         if (node->clones)
 754           node = node->clones;
 755         else if (node->next_sibling_clone)
 756           node = node->next_sibling_clone;
 757         else
 758           {
 759             while (node != orig && !node->next_sibling_clone)
 760               node = node->clone_of;
 761             if (node != orig)
 762               node = node->next_sibling_clone;
 763           }
 764       }
 765 }
 766
 767
 768 /* Input the base body of struct function FN from DATA_IN
 769    using input block IB.  */
 770
 771 static void
 772 input_struct_function_base (struct function *fn, struct data_in *data_in,
 773                             struct lto_input_block *ib)
 774 {
 775   struct bitpack_d bp;
 776   int len;
 777
 778   /* Read the static chain and non-local goto save area.  */
 779   fn->static_chain_decl = stream_read_tree (ib, data_in);
 780   fn->nonlocal_goto_save_area = stream_read_tree (ib, data_in);
 781
 782   /* Read all the local symbols.  */
 783   len = streamer_read_hwi (ib);
 784   if (len > 0)
 785     {
 786       int i;
 787       VEC_safe_grow (tree, gc, fn->local_decls, len);
 788       for (i = 0; i < len; i++)
 789         {
 790           tree t = stream_read_tree (ib, data_in);
 791           VEC_replace (tree, fn->local_decls, i, t);
 792         }
 793     }
 794
 795   /* Input the function start and end loci.  */
 796   fn->function_start_locus = lto_input_location (ib, data_in);
 797   fn->function_end_locus = lto_input_location (ib, data_in);
 798
 799   /* Input the current IL state of the function.  */
 800   fn->curr_properties = streamer_read_uhwi (ib);
 801
 802   /* Read all the attributes for FN.  */
 803   bp = streamer_read_bitpack (ib);
 804   fn->is_thunk = bp_unpack_value (&bp, 1);
 805   fn->has_local_explicit_reg_vars = bp_unpack_value (&bp, 1);
 806   fn->after_tree_profile = bp_unpack_value (&bp, 1);
 807   fn->returns_pcc_struct = bp_unpack_value (&bp, 1);
 808   fn->returns_struct = bp_unpack_value (&bp, 1);
 809   fn->can_throw_non_call_exceptions = bp_unpack_value (&bp, 1);
 810   fn->always_inline_functions_inlined = bp_unpack_value (&bp, 1);
 811   fn->after_inlining = bp_unpack_value (&bp, 1);
 812   fn->stdarg = bp_unpack_value (&bp, 1);
 813   fn->has_nonlocal_label = bp_unpack_value (&bp, 1);
 814   fn->calls_alloca = bp_unpack_value (&bp, 1);
 815   fn->calls_setjmp = bp_unpack_value (&bp, 1);
 816   fn->va_list_fpr_size = bp_unpack_value (&bp, 8);
 817   fn->va_list_gpr_size = bp_unpack_value (&bp, 8);
 818 }
 819
 820
 821 /* Read the body of function FN_DECL from DATA_IN using input block IB.  */
 822
 823 static void
 824 input_function (tree fn_decl, struct data_in *data_in,
 825                 struct lto_input_block *ib)
 826 {
 827   struct function *fn;
 828   enum LTO_tags tag;
 829   gimple *stmts;
 830   basic_block bb;
 831   struct cgraph_node *node;
 832   tree args, narg, oarg;
 833
 834   fn = DECL_STRUCT_FUNCTION (fn_decl);
 835   tag = streamer_read_record_start (ib);
 836   clear_line_info (data_in);
 837
 838   gimple_register_cfg_hooks ();
 839   lto_tag_check (tag, LTO_function);
 840
 841   input_struct_function_base (fn, data_in, ib);
 842
 843   /* Read all function arguments.  We need to re-map them here to the
 844      arguments of the merged function declaration.  */
 845   args = stream_read_tree (ib, data_in);
 846   for (oarg = args, narg = DECL_ARGUMENTS (fn_decl);
 847        oarg && narg;
 848        oarg = TREE_CHAIN (oarg), narg = TREE_CHAIN (narg))
 849     {
 850       unsigned ix;
 851       bool res;
 852       res = streamer_tree_cache_lookup (data_in->reader_cache, oarg, &ix);
 853       gcc_assert (res);
 854       /* Replace the argument in the streamer cache.  */
 855       streamer_tree_cache_insert_at (data_in->reader_cache, narg, ix);
 856     }
 857   gcc_assert (!oarg && !narg);
 858
 859   /* Read all the SSA names.  */
 860   input_ssa_names (ib, data_in, fn);
 861
 862   /* Read the exception handling regions in the function.  */
 863   input_eh_regions (ib, data_in, fn);
 864
 865   /* Read the tree of lexical scopes for the function.  */
 866   DECL_INITIAL (fn_decl) = stream_read_tree (ib, data_in);
 867   gcc_assert (DECL_INITIAL (fn_decl));
 868   DECL_SAVED_TREE (fn_decl) = NULL_TREE;
 869   node = cgraph_get_create_node (fn_decl);
 870
 871   /* Read all the basic blocks.  */
 872   tag = streamer_read_record_start (ib);
 873   while (tag)
 874     {
 875       input_bb (ib, tag, data_in, fn,
 876                 node->count_materialization_scale);
 877       tag = streamer_read_record_start (ib);
 878     }
 879
 880   /* Fix up the call statements that are mentioned in the callgraph
 881      edges.  */
 882   set_gimple_stmt_max_uid (cfun, 0);
 883   FOR_ALL_BB (bb)
 884     {
 885       gimple_stmt_iterator gsi;
 886       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 887         {
 888           gimple stmt = gsi_stmt (gsi);
 889           gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
 890         }
 891     }
 892   stmts = (gimple *) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple));
 893   FOR_ALL_BB (bb)
 894     {
 895       gimple_stmt_iterator bsi = gsi_start_bb (bb);
 896       while (!gsi_end_p (bsi))
 897         {
 898           gimple stmt = gsi_stmt (bsi);
 899           /* If we're recompiling LTO objects with debug stmts but
 900              we're not supposed to have debug stmts, remove them now.
 901              We can't remove them earlier because this would cause uid
 902              mismatches in fixups, but we can do it at this point, as
 903              long as debug stmts don't require fixups.  */
 904           if (!MAY_HAVE_DEBUG_STMTS && is_gimple_debug (stmt))
 905             {
 906               gimple_stmt_iterator gsi = bsi;
 907               gsi_next (&bsi);
 908               gsi_remove (&gsi, true);
 909             }
 910           else
 911             {
 912               gsi_next (&bsi);
 913               stmts[gimple_uid (stmt)] = stmt;
 914             }
 915         }
 916     }
 917
 918   /* Set the gimple body to the statement sequence in the entry
 919      basic block.  FIXME lto, this is fairly hacky.  The existence
 920      of a gimple body is used by the cgraph routines, but we should
 921      really use the presence of the CFG.  */
 922   {
 923     edge_iterator ei = ei_start (ENTRY_BLOCK_PTR->succs);
 924     gimple_set_body (fn_decl, bb_seq (ei_edge (ei)->dest));
 925   }
 926
 927   fixup_call_stmt_edges (node, stmts);
 928   execute_all_ipa_stmt_fixups (node, stmts);
 929
 930   update_ssa (TODO_update_ssa_only_virtuals);
 931   free_dominance_info (CDI_DOMINATORS);
 932   free_dominance_info (CDI_POST_DOMINATORS);
 933   free (stmts);
 934 }
 935
 936
 937 /* Read initializer expressions for public statics.  DATA_IN is the
 938    file being read.  IB is the input block used for reading.  */
 939
 940 static void
 941 input_alias_pairs (struct lto_input_block *ib, struct data_in *data_in)
 942 {
 943   tree var;
 944
 945   clear_line_info (data_in);
 946
 947   var = stream_read_tree (ib, data_in);
 948   while (var)
 949     {
 950       const char *orig_name, *new_name;
 951       alias_pair *p;
 952
 953       p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
 954       p->decl = var;
 955       p->target = stream_read_tree (ib, data_in);
 956
 957       /* If the target is a static object, we may have registered a
 958          new name for it to avoid clashes between statics coming from
 959          different files.  In that case, use the new name.  */
 960       orig_name = IDENTIFIER_POINTER (p->target);
 961       new_name = lto_get_decl_name_mapping (data_in->file_data, orig_name);
 962       if (strcmp (orig_name, new_name) != 0)
 963         p->target = get_identifier (new_name);
 964
 965       var = stream_read_tree (ib, data_in);
 966     }
 967 }
 968
 969
 970 /* Read the body from DATA for function FN_DECL and fill it in.
 971    FILE_DATA are the global decls and types.  SECTION_TYPE is either
 972    LTO_section_function_body or LTO_section_static_initializer.  If
 973    section type is LTO_section_function_body, FN must be the decl for
 974    that function.  */
 975
 976 static void
 977 lto_read_body (struct lto_file_decl_data *file_data, tree fn_decl,
 978                const char *data, enum lto_section_type section_type)
 979 {
 980   const struct lto_function_header *header;
 981   struct data_in *data_in;
 982   int cfg_offset;
 983   int main_offset;
 984   int string_offset;
 985   struct lto_input_block ib_cfg;
 986   struct lto_input_block ib_main;
 987
 988   header = (const struct lto_function_header *) data;
 989   cfg_offset = sizeof (struct lto_function_header);
 990   main_offset = cfg_offset + header->cfg_size;
 991   string_offset = main_offset + header->main_size;
 992
 993   LTO_INIT_INPUT_BLOCK (ib_cfg,
 994                         data + cfg_offset,
 995                         0,
 996                         header->cfg_size);
 997
 998   LTO_INIT_INPUT_BLOCK (ib_main,
 999                         data + main_offset,
1000                         0,
1001                         header->main_size);
1002
1003   data_in = lto_data_in_create (file_data, data + string_offset,
1004                                 header->string_size, NULL);
1005
1006   /* Make sure the file was generated by the exact same compiler.  */
1007   lto_check_version (header->lto_header.major_version,
1008                      header->lto_header.minor_version);
1009
1010   if (section_type == LTO_section_function_body)
1011     {
1012       struct function *fn = DECL_STRUCT_FUNCTION (fn_decl);
1013       struct lto_in_decl_state *decl_state;
1014       struct cgraph_node *node = cgraph_get_node (fn_decl);
1015       unsigned from;
1016
1017       gcc_checking_assert (node);
1018       push_cfun (fn);
1019       init_tree_ssa (fn);
1020
1021       /* Use the function's decl state. */
1022       decl_state = lto_get_function_in_decl_state (file_data, fn_decl);
1023       gcc_assert (decl_state);
1024       file_data->current_decl_state = decl_state;
1025
1026       input_cfg (&ib_cfg, fn, node->count_materialization_scale);
1027
1028       /* Set up the struct function.  */
1029       from = VEC_length (tree, data_in->reader_cache->nodes);
1030       input_function (fn_decl, data_in, &ib_main);
1031       /* And fixup types we streamed locally.  */
1032         {
1033           struct streamer_tree_cache_d *cache = data_in->reader_cache;
1034           unsigned len = VEC_length (tree, cache->nodes);
1035           unsigned i;
1036           for (i = len; i-- > from;)
1037             {
1038               tree t = VEC_index (tree, cache->nodes, i);
1039               if (t == NULL_TREE)
1040                 continue;
1041
1042               if (TYPE_P (t))
1043                 {
1044                   gcc_assert (TYPE_CANONICAL (t) == NULL_TREE);
1045                   TYPE_CANONICAL (t) = TYPE_MAIN_VARIANT (t);
1046                   if (TYPE_MAIN_VARIANT (t) != t)
1047                     {
1048                       gcc_assert (TYPE_NEXT_VARIANT (t) == NULL_TREE);
1049                       TYPE_NEXT_VARIANT (t)
1050                         = TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t));
1051                       TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t)) = t;
1052                     }
1053                 }
1054             }
1055         }
1056
1057       /* We should now be in SSA.  */
1058       cfun->gimple_df->in_ssa_p = true;
1059
1060       /* Restore decl state */
1061       file_data->current_decl_state = file_data->global_decl_state;
1062
1063       pop_cfun ();
1064     }
1065   else
1066     {
1067       input_alias_pairs (&ib_main, data_in);
1068     }
1069
1070   clear_line_info (data_in);
1071   lto_data_in_delete (data_in);
1072 }
1073
1074
1075 /* Read the body of FN_DECL using DATA.  FILE_DATA holds the global
1076    decls and types.  */
1077
1078 void
1079 lto_input_function_body (struct lto_file_decl_data *file_data,
1080                          tree fn_decl, const char *data)
1081 {
1082   current_function_decl = fn_decl;
1083   lto_read_body (file_data, fn_decl, data, LTO_section_function_body);
1084 }
1085
1086
1087 /* Read in VAR_DECL using DATA.  FILE_DATA holds the global decls and
1088    types.  */
1089
1090 void
1091 lto_input_constructors_and_inits (struct lto_file_decl_data *file_data,
1092                                   const char *data)
1093 {
1094   lto_read_body (file_data, NULL, data, LTO_section_static_initializer);
1095 }
1096
1097
1098 /* Read the physical representation of a tree node with tag TAG from
1099    input block IB using the per-file context in DATA_IN.  */
1100
1101 static tree
1102 lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
1103                enum LTO_tags tag)
1104 {
1105   /* Instantiate a new tree node.  */
1106   tree result = streamer_alloc_tree (ib, data_in, tag);
1107
1108   /* Enter RESULT in the reader cache.  This will make RESULT
1109      available so that circular references in the rest of the tree
1110      structure can be resolved in subsequent calls to stream_read_tree.  */
1111   streamer_tree_cache_append (data_in->reader_cache, result);
1112
1113   /* Read all the bitfield values in RESULT.  Note that for LTO, we
1114      only write language-independent bitfields, so no more unpacking is
1115      needed.  */
1116   streamer_read_tree_bitfields (ib, result);
1117
1118   /* Read all the pointer fields in RESULT.  */
1119   streamer_read_tree_body (ib, data_in, result);
1120
1121   /* Read any LTO-specific data not read by the tree streamer.  */
1122   if (DECL_P (result)
1123       && TREE_CODE (result) != FUNCTION_DECL
1124       && TREE_CODE (result) != TRANSLATION_UNIT_DECL)
1125     DECL_INITIAL (result) = stream_read_tree (ib, data_in);
1126
1127   /* We should never try to instantiate an MD or NORMAL builtin here.  */
1128   if (TREE_CODE (result) == FUNCTION_DECL)
1129     gcc_assert (!streamer_handle_as_builtin_p (result));
1130
1131   /* end_marker = */ streamer_read_uchar (ib);
1132
1133 #ifdef LTO_STREAMER_DEBUG
1134   /* Remove the mapping to RESULT's original address set by
1135      streamer_alloc_tree.  */
1136   lto_orig_address_remove (result);
1137 #endif
1138
1139   return result;
1140 }
1141
1142
1143 /* Read a tree from input block IB using the per-file context in
1144    DATA_IN.  This context is used, for example, to resolve references
1145    to previously read nodes.  */
1146
1147 tree
1148 lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
1149 {
1150   enum LTO_tags tag;
1151   tree result;
1152
1153   tag = streamer_read_record_start (ib);
1154   gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
1155
1156   if (tag == LTO_null)
1157     result = NULL_TREE;
1158   else if (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
1159     {
1160       /* If TAG is a reference to an indexable tree, the next value
1161          in IB is the index into the table where we expect to find
1162          that tree.  */
1163       result = lto_input_tree_ref (ib, data_in, cfun, tag);
1164     }
1165   else if (tag == LTO_tree_pickle_reference)
1166     {
1167       /* If TAG is a reference to a previously read tree, look it up in
1168          the reader cache.  */
1169       result = streamer_get_pickled_tree (ib, data_in);
1170     }
1171   else if (tag == LTO_builtin_decl)
1172     {
1173       /* If we are going to read a built-in function, all we need is
1174          the code and class.  */
1175       result = streamer_get_builtin_tree (ib, data_in);
1176     }
1177   else if (tag == lto_tree_code_to_tag (INTEGER_CST))
1178     {
1179       /* For integer constants we only need the type and its hi/low
1180          words.  */
1181       result = streamer_read_integer_cst (ib, data_in);
1182     }
1183   else
1184     {
1185       /* Otherwise, materialize a new node from IB.  */
1186       result = lto_read_tree (ib, data_in, tag);
1187     }
1188
1189   return result;
1190 }
1191
1192
1193 /* Input toplevel asms.  */
1194
1195 void
1196 lto_input_toplevel_asms (struct lto_file_decl_data *file_data, int order_base)
1197 {
1198   size_t len;
1199   const char *data = lto_get_section_data (file_data, LTO_section_asm,
1200                                            NULL, &len);
1201   const struct lto_asm_header *header = (const struct lto_asm_header *) data;
1202   int string_offset;
1203   struct data_in *data_in;
1204   struct lto_input_block ib;
1205   tree str;
1206
1207   if (! data)
1208     return;
1209
1210   string_offset = sizeof (*header) + header->main_size;
1211
1212   LTO_INIT_INPUT_BLOCK (ib,
1213                         data + sizeof (*header),
1214                         0,
1215                         header->main_size);
1216
1217   data_in = lto_data_in_create (file_data, data + string_offset,
1218                                 header->string_size, NULL);
1219
1220   /* Make sure the file was generated by the exact same compiler.  */
1221   lto_check_version (header->lto_header.major_version,
1222                      header->lto_header.minor_version);
1223
1224   while ((str = streamer_read_string_cst (data_in, &ib)))
1225     {
1226       struct cgraph_asm_node *node = cgraph_add_asm_node (str);
1227       node->order = streamer_read_hwi (&ib) + order_base;
1228       if (node->order >= cgraph_order)
1229         cgraph_order = node->order + 1;
1230     }
1231
1232   clear_line_info (data_in);
1233   lto_data_in_delete (data_in);
1234
1235   lto_free_section_data (file_data, LTO_section_asm, NULL, data, len);
1236 }
1237
1238
1239 /* Initialization for the LTO reader.  */
1240
1241 void
1242 lto_reader_init (void)
1243 {
1244   lto_streamer_init ();
1245   file_name_hash_table = htab_create (37, hash_string_slot_node,
1246                                       eq_string_slot_node, free);
1247 }
1248
1249
1250 /* Create a new data_in object for FILE_DATA. STRINGS is the string
1251    table to use with LEN strings.  RESOLUTIONS is the vector of linker
1252    resolutions (NULL if not using a linker plugin).  */
1253
1254 struct data_in *
1255 lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
1256                     unsigned len,
1257                     VEC(ld_plugin_symbol_resolution_t,heap) *resolutions)
1258 {
1259   struct data_in *data_in = XCNEW (struct data_in);
1260   data_in->file_data = file_data;
1261   data_in->strings = strings;
1262   data_in->strings_len = len;
1263   data_in->globals_resolution = resolutions;
1264   data_in->reader_cache = streamer_tree_cache_create ();
1265
1266   return data_in;
1267 }
1268
1269
1270 /* Remove DATA_IN.  */
1271
1272 void
1273 lto_data_in_delete (struct data_in *data_in)
1274 {
1275   VEC_free (ld_plugin_symbol_resolution_t, heap, data_in->globals_resolution);
1276   streamer_tree_cache_delete (data_in->reader_cache);
1277   free (data_in->labels);
1278   free (data_in);
1279 }