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   int32_t cfg_offset;
 983   int32_t main_offset;
 984   int32_t 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
1016       gcc_checking_assert (node);
1017       push_cfun (fn);
1018       init_tree_ssa (fn);
1019
1020       /* Use the function's decl state. */
1021       decl_state = lto_get_function_in_decl_state (file_data, fn_decl);
1022       gcc_assert (decl_state);
1023       file_data->current_decl_state = decl_state;
1024
1025       input_cfg (&ib_cfg, fn, node->count_materialization_scale);
1026
1027       /* Set up the struct function.  */
1028       input_function (fn_decl, data_in, &ib_main);
1029
1030       /* We should now be in SSA.  */
1031       cfun->gimple_df->in_ssa_p = true;
1032
1033       /* Restore decl state */
1034       file_data->current_decl_state = file_data->global_decl_state;
1035
1036       pop_cfun ();
1037     }
1038   else
1039     {
1040       input_alias_pairs (&ib_main, data_in);
1041     }
1042
1043   clear_line_info (data_in);
1044   lto_data_in_delete (data_in);
1045 }
1046
1047
1048 /* Read the body of FN_DECL using DATA.  FILE_DATA holds the global
1049    decls and types.  */
1050
1051 void
1052 lto_input_function_body (struct lto_file_decl_data *file_data,
1053                          tree fn_decl, const char *data)
1054 {
1055   current_function_decl = fn_decl;
1056   lto_read_body (file_data, fn_decl, data, LTO_section_function_body);
1057 }
1058
1059
1060 /* Read in VAR_DECL using DATA.  FILE_DATA holds the global decls and
1061    types.  */
1062
1063 void
1064 lto_input_constructors_and_inits (struct lto_file_decl_data *file_data,
1065                                   const char *data)
1066 {
1067   lto_read_body (file_data, NULL, data, LTO_section_static_initializer);
1068 }
1069
1070
1071 /* Read the physical representation of a tree node with tag TAG from
1072    input block IB using the per-file context in DATA_IN.  */
1073
1074 static tree
1075 lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
1076                enum LTO_tags tag)
1077 {
1078   /* Instantiate a new tree node.  */
1079   tree result = streamer_alloc_tree (ib, data_in, tag);
1080
1081   /* Enter RESULT in the reader cache.  This will make RESULT
1082      available so that circular references in the rest of the tree
1083      structure can be resolved in subsequent calls to stream_read_tree.  */
1084   streamer_tree_cache_append (data_in->reader_cache, result);
1085
1086   /* Read all the bitfield values in RESULT.  Note that for LTO, we
1087      only write language-independent bitfields, so no more unpacking is
1088      needed.  */
1089   streamer_read_tree_bitfields (ib, result);
1090
1091   /* Read all the pointer fields in RESULT.  */
1092   streamer_read_tree_body (ib, data_in, result);
1093
1094   /* Read any LTO-specific data not read by the tree streamer.  */
1095   if (DECL_P (result)
1096       && TREE_CODE (result) != FUNCTION_DECL
1097       && TREE_CODE (result) != TRANSLATION_UNIT_DECL)
1098     DECL_INITIAL (result) = stream_read_tree (ib, data_in);
1099
1100   /* We should never try to instantiate an MD or NORMAL builtin here.  */
1101   if (TREE_CODE (result) == FUNCTION_DECL)
1102     gcc_assert (!streamer_handle_as_builtin_p (result));
1103
1104   /* end_marker = */ streamer_read_uchar (ib);
1105
1106 #ifdef LTO_STREAMER_DEBUG
1107   /* Remove the mapping to RESULT's original address set by
1108      streamer_alloc_tree.  */
1109   lto_orig_address_remove (result);
1110 #endif
1111
1112   return result;
1113 }
1114
1115
1116 /* Read a tree from input block IB using the per-file context in
1117    DATA_IN.  This context is used, for example, to resolve references
1118    to previously read nodes.  */
1119
1120 tree
1121 lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
1122 {
1123   enum LTO_tags tag;
1124   tree result;
1125
1126   tag = streamer_read_record_start (ib);
1127   gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
1128
1129   if (tag == LTO_null)
1130     result = NULL_TREE;
1131   else if (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
1132     {
1133       /* If TAG is a reference to an indexable tree, the next value
1134          in IB is the index into the table where we expect to find
1135          that tree.  */
1136       result = lto_input_tree_ref (ib, data_in, cfun, tag);
1137     }
1138   else if (tag == LTO_tree_pickle_reference)
1139     {
1140       /* If TAG is a reference to a previously read tree, look it up in
1141          the reader cache.  */
1142       result = streamer_get_pickled_tree (ib, data_in);
1143     }
1144   else if (tag == LTO_builtin_decl)
1145     {
1146       /* If we are going to read a built-in function, all we need is
1147          the code and class.  */
1148       result = streamer_get_builtin_tree (ib, data_in);
1149     }
1150   else if (tag == lto_tree_code_to_tag (INTEGER_CST))
1151     {
1152       /* For integer constants we only need the type and its hi/low
1153          words.  */
1154       result = streamer_read_integer_cst (ib, data_in);
1155     }
1156   else
1157     {
1158       /* Otherwise, materialize a new node from IB.  */
1159       result = lto_read_tree (ib, data_in, tag);
1160     }
1161
1162   return result;
1163 }
1164
1165
1166 /* Input toplevel asms.  */
1167
1168 void
1169 lto_input_toplevel_asms (struct lto_file_decl_data *file_data, int order_base)
1170 {
1171   size_t len;
1172   const char *data = lto_get_section_data (file_data, LTO_section_asm,
1173                                            NULL, &len);
1174   const struct lto_asm_header *header = (const struct lto_asm_header *) data;
1175   int32_t string_offset;
1176   struct data_in *data_in;
1177   struct lto_input_block ib;
1178   tree str;
1179
1180   if (! data)
1181     return;
1182
1183   string_offset = sizeof (*header) + header->main_size;
1184
1185   LTO_INIT_INPUT_BLOCK (ib,
1186                         data + sizeof (*header),
1187                         0,
1188                         header->main_size);
1189
1190   data_in = lto_data_in_create (file_data, data + string_offset,
1191                                 header->string_size, NULL);
1192
1193   /* Make sure the file was generated by the exact same compiler.  */
1194   lto_check_version (header->lto_header.major_version,
1195                      header->lto_header.minor_version);
1196
1197   while ((str = streamer_read_string_cst (data_in, &ib)))
1198     {
1199       struct cgraph_asm_node *node = cgraph_add_asm_node (str);
1200       node->order = streamer_read_hwi (&ib) + order_base;
1201       if (node->order >= cgraph_order)
1202         cgraph_order = node->order + 1;
1203     }
1204
1205   clear_line_info (data_in);
1206   lto_data_in_delete (data_in);
1207
1208   lto_free_section_data (file_data, LTO_section_asm, NULL, data, len);
1209 }
1210
1211
1212 /* Initialization for the LTO reader.  */
1213
1214 void
1215 lto_reader_init (void)
1216 {
1217   lto_streamer_init ();
1218   file_name_hash_table = htab_create (37, hash_string_slot_node,
1219                                       eq_string_slot_node, free);
1220 }
1221
1222
1223 /* Create a new data_in object for FILE_DATA. STRINGS is the string
1224    table to use with LEN strings.  RESOLUTIONS is the vector of linker
1225    resolutions (NULL if not using a linker plugin).  */
1226
1227 struct data_in *
1228 lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
1229                     unsigned len,
1230                     VEC(ld_plugin_symbol_resolution_t,heap) *resolutions)
1231 {
1232   struct data_in *data_in = XCNEW (struct data_in);
1233   data_in->file_data = file_data;
1234   data_in->strings = strings;
1235   data_in->strings_len = len;
1236   data_in->globals_resolution = resolutions;
1237   data_in->reader_cache = streamer_tree_cache_create ();
1238
1239   return data_in;
1240 }
1241
1242
1243 /* Remove DATA_IN.  */
1244
1245 void
1246 lto_data_in_delete (struct data_in *data_in)
1247 {
1248   VEC_free (ld_plugin_symbol_resolution_t, heap, data_in->globals_resolution);
1249   streamer_tree_cache_delete (data_in->reader_cache);
1250   free (data_in->labels);
1251   free (data_in);
1252 }