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 "lto-streamer.h"
  49 #include "tree-pass.h"
  50
  51 /* Data structure used to hash file names in the source_location field.  */
  52 struct string_slot
  53 {
  54   const char *s;
  55   unsigned int slot_num;
  56 };
  57
  58 /* The table to hold the file names.  */
  59 static htab_t file_name_hash_table;
  60
  61
  62 /* Check that tag ACTUAL has one of the given values.  NUM_TAGS is the
  63    number of valid tag values to check.  */
  64
  65 static void
  66 lto_tag_check_set (enum LTO_tags actual, int ntags, ...)
  67 {
  68   va_list ap;
  69   int i;
  70
  71   va_start (ap, ntags);
  72   for (i = 0; i < ntags; i++)
  73     if ((unsigned) actual == va_arg (ap, unsigned))
  74       {
  75         va_end (ap);
  76         return;
  77       }
  78
  79   va_end (ap);
  80   internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual));
  81 }
  82
  83
  84 /* Check that tag ACTUAL is in the range [TAG1, TAG2].  */
  85
  86 static void
  87 lto_tag_check_range (enum LTO_tags actual, enum LTO_tags tag1,
  88                      enum LTO_tags tag2)
  89 {
  90   if (actual < tag1 || actual > tag2)
  91     internal_error ("bytecode stream: tag %s is not in the expected range "
  92                     "[%s, %s]",
  93                     lto_tag_name (actual),
  94                     lto_tag_name (tag1),
  95                     lto_tag_name (tag2));
  96 }
  97
  98
  99 /* Check that tag ACTUAL == EXPECTED.  */
 100
 101 static void
 102 lto_tag_check (enum LTO_tags actual, enum LTO_tags expected)
 103 {
 104   if (actual != expected)
 105     internal_error ("bytecode stream: expected tag %s instead of %s",
 106                     lto_tag_name (expected), lto_tag_name (actual));
 107 }
 108
 109
 110 /* Return a hash code for P.  */
 111
 112 static hashval_t
 113 hash_string_slot_node (const void *p)
 114 {
 115   const struct string_slot *ds = (const struct string_slot *) p;
 116   return (hashval_t) htab_hash_string (ds->s);
 117 }
 118
 119
 120 /* Returns nonzero if P1 and P2 are equal.  */
 121
 122 static int
 123 eq_string_slot_node (const void *p1, const void *p2)
 124 {
 125   const struct string_slot *ds1 = (const struct string_slot *) p1;
 126   const struct string_slot *ds2 = (const struct string_slot *) p2;
 127   return strcmp (ds1->s, ds2->s) == 0;
 128 }
 129
 130
 131 /* Read a string from the string table in DATA_IN using input block
 132    IB.  Write the length to RLEN.  */
 133
 134 static const char *
 135 input_string_internal (struct data_in *data_in, struct lto_input_block *ib,
 136                        unsigned int *rlen)
 137 {
 138   struct lto_input_block str_tab;
 139   unsigned int len;
 140   unsigned int loc;
 141   const char *result;
 142
 143   /* Read the location of the string from IB.  */
 144   loc = lto_input_uleb128 (ib);
 145
 146   /* Get the string stored at location LOC in DATA_IN->STRINGS.  */
 147   LTO_INIT_INPUT_BLOCK (str_tab, data_in->strings, loc, data_in->strings_len);
 148   len = lto_input_uleb128 (&str_tab);
 149   *rlen = len;
 150
 151   if (str_tab.p + len > data_in->strings_len)
 152     internal_error ("bytecode stream: string too long for the string table");
 153
 154   result = (const char *)(data_in->strings + str_tab.p);
 155
 156   return result;
 157 }
 158
 159
 160 /* Read a STRING_CST from the string table in DATA_IN using input
 161    block IB.  */
 162
 163 static tree
 164 input_string_cst (struct data_in *data_in, struct lto_input_block *ib)
 165 {
 166   unsigned int len;
 167   const char * ptr;
 168   unsigned int is_null;
 169
 170   is_null = lto_input_uleb128 (ib);
 171   if (is_null)
 172     return NULL;
 173
 174   ptr = input_string_internal (data_in, ib, &len);
 175   return build_string (len, ptr);
 176 }
 177
 178
 179 /* Read an IDENTIFIER from the string table in DATA_IN using input
 180    block IB.  */
 181
 182 static tree
 183 input_identifier (struct data_in *data_in, struct lto_input_block *ib)
 184 {
 185   unsigned int len;
 186   const char *ptr;
 187   unsigned int is_null;
 188
 189   is_null = lto_input_uleb128 (ib);
 190   if (is_null)
 191     return NULL;
 192
 193   ptr = input_string_internal (data_in, ib, &len);
 194   return get_identifier_with_length (ptr, len);
 195 }
 196
 197
 198 /* Read LENGTH bytes from STREAM to ADDR.  */
 199
 200 void
 201 lto_input_data_block (struct lto_input_block *ib, void *addr, size_t length)
 202 {
 203   size_t i;
 204   unsigned char *const buffer = (unsigned char *const) addr;
 205
 206   for (i = 0; i < length; i++)
 207     buffer[i] = lto_input_1_unsigned (ib);
 208 }
 209
 210
 211 /* Read a NULL terminated string from the string table in DATA_IN.  */
 212
 213 const char *
 214 lto_input_string (struct data_in *data_in, struct lto_input_block *ib)
 215 {
 216   unsigned int len;
 217   const char *ptr;
 218   unsigned int is_null;
 219
 220   is_null = lto_input_uleb128 (ib);
 221   if (is_null)
 222     return NULL;
 223
 224   ptr = input_string_internal (data_in, ib, &len);
 225   if (ptr[len - 1] != '\0')
 226     internal_error ("bytecode stream: found non-null terminated string");
 227
 228   return ptr;
 229 }
 230
 231
 232 /* Return the next tag in the input block IB.  */
 233
 234 static enum LTO_tags
 235 input_record_start (struct lto_input_block *ib)
 236 {
 237   enum LTO_tags tag = (enum LTO_tags) lto_input_uleb128 (ib);
 238   return tag;
 239 }
 240
 241
 242 /* Lookup STRING in file_name_hash_table.  If found, return the existing
 243    string, otherwise insert STRING as the canonical version.  */
 244
 245 static const char *
 246 canon_file_name (const char *string)
 247 {
 248   void **slot;
 249   struct string_slot s_slot;
 250   s_slot.s = string;
 251
 252   slot = htab_find_slot (file_name_hash_table, &s_slot, INSERT);
 253   if (*slot == NULL)
 254     {
 255       size_t len;
 256       char *saved_string;
 257       struct string_slot *new_slot;
 258
 259       len = strlen (string);
 260       saved_string = (char *) xmalloc (len + 1);
 261       new_slot = XCNEW (struct string_slot);
 262       strcpy (saved_string, string);
 263       new_slot->s = saved_string;
 264       *slot = new_slot;
 265       return saved_string;
 266     }
 267   else
 268     {
 269       struct string_slot *old_slot = (struct string_slot *) *slot;
 270       return old_slot->s;
 271     }
 272 }
 273
 274
 275 /* Clear the line info stored in DATA_IN.  */
 276
 277 static void
 278 clear_line_info (struct data_in *data_in)
 279 {
 280   if (data_in->current_file)
 281     linemap_add (line_table, LC_LEAVE, false, NULL, 0);
 282   data_in->current_file = NULL;
 283   data_in->current_line = 0;
 284   data_in->current_col = 0;
 285 }
 286
 287
 288 /* Read a location from input block IB.  */
 289
 290 static location_t
 291 lto_input_location (struct lto_input_block *ib, struct data_in *data_in)
 292 {
 293   expanded_location xloc;
 294
 295   xloc.file = lto_input_string (data_in, ib);
 296   if (xloc.file == NULL)
 297     return UNKNOWN_LOCATION;
 298
 299   xloc.file = canon_file_name (xloc.file);
 300   xloc.line = lto_input_sleb128 (ib);
 301   xloc.column = lto_input_sleb128 (ib);
 302   xloc.sysp = lto_input_sleb128 (ib);
 303
 304   if (data_in->current_file != xloc.file)
 305     {
 306       if (data_in->current_file)
 307         linemap_add (line_table, LC_LEAVE, false, NULL, 0);
 308
 309       linemap_add (line_table, LC_ENTER, xloc.sysp, xloc.file, xloc.line);
 310     }
 311   else if (data_in->current_line != xloc.line)
 312     linemap_line_start (line_table, xloc.line, xloc.column);
 313
 314   data_in->current_file = xloc.file;
 315   data_in->current_line = xloc.line;
 316   data_in->current_col = xloc.column;
 317
 318   return linemap_position_for_column (line_table, xloc.column);
 319 }
 320
 321
 322 /* Read a reference to a tree node from DATA_IN using input block IB.
 323    TAG is the expected node that should be found in IB, if TAG belongs
 324    to one of the indexable trees, expect to read a reference index to
 325    be looked up in one of the symbol tables, otherwise read the pysical
 326    representation of the tree using lto_input_tree.  FN is the
 327    function scope for the read tree.  */
 328
 329 static tree
 330 lto_input_tree_ref (struct lto_input_block *ib, struct data_in *data_in,
 331                     struct function *fn, enum LTO_tags tag)
 332 {
 333   unsigned HOST_WIDE_INT ix_u;
 334   tree result = NULL_TREE;
 335
 336   lto_tag_check_range (tag, LTO_field_decl_ref, LTO_global_decl_ref);
 337
 338   switch (tag)
 339     {
 340     case LTO_type_ref:
 341       ix_u = lto_input_uleb128 (ib);
 342       result = lto_file_decl_data_get_type (data_in->file_data, ix_u);
 343       break;
 344
 345     case LTO_ssa_name_ref:
 346       ix_u = lto_input_uleb128 (ib);
 347       result = VEC_index (tree, SSANAMES (fn), ix_u);
 348       break;
 349
 350     case LTO_field_decl_ref:
 351       ix_u = lto_input_uleb128 (ib);
 352       result = lto_file_decl_data_get_field_decl (data_in->file_data, ix_u);
 353       break;
 354
 355     case LTO_function_decl_ref:
 356       ix_u = lto_input_uleb128 (ib);
 357       result = lto_file_decl_data_get_fn_decl (data_in->file_data, ix_u);
 358       break;
 359
 360     case LTO_type_decl_ref:
 361       ix_u = lto_input_uleb128 (ib);
 362       result = lto_file_decl_data_get_type_decl (data_in->file_data, ix_u);
 363       break;
 364
 365     case LTO_namespace_decl_ref:
 366       ix_u = lto_input_uleb128 (ib);
 367       result = lto_file_decl_data_get_namespace_decl (data_in->file_data, ix_u);
 368       break;
 369
 370     case LTO_global_decl_ref:
 371     case LTO_result_decl_ref:
 372     case LTO_const_decl_ref:
 373     case LTO_imported_decl_ref:
 374     case LTO_label_decl_ref:
 375     case LTO_translation_unit_decl_ref:
 376       ix_u = lto_input_uleb128 (ib);
 377       result = lto_file_decl_data_get_var_decl (data_in->file_data, ix_u);
 378       break;
 379
 380     default:
 381       gcc_unreachable ();
 382     }
 383
 384   gcc_assert (result);
 385
 386   return result;
 387 }
 388
 389
 390 /* Read a chain of tree nodes from input block IB. DATA_IN contains
 391    tables and descriptors for the file being read.  */
 392
 393 static tree
 394 lto_input_chain (struct lto_input_block *ib, struct data_in *data_in)
 395 {
 396   int i, count;
 397   tree first, prev, curr;
 398
 399   first = prev = NULL_TREE;
 400   count = lto_input_sleb128 (ib);
 401   for (i = 0; i < count; i++)
 402     {
 403       curr = lto_input_tree (ib, data_in);
 404       if (prev)
 405         TREE_CHAIN (prev) = curr;
 406       else
 407         first = curr;
 408
 409       TREE_CHAIN (curr) = NULL_TREE;
 410       prev = curr;
 411     }
 412
 413   return first;
 414 }
 415
 416
 417 /* Read and return a double-linked list of catch handlers from input
 418    block IB, using descriptors in DATA_IN.  */
 419
 420 static struct eh_catch_d *
 421 lto_input_eh_catch_list (struct lto_input_block *ib, struct data_in *data_in,
 422                          eh_catch *last_p)
 423 {
 424   eh_catch first;
 425   enum LTO_tags tag;
 426
 427   *last_p = first = NULL;
 428   tag = input_record_start (ib);
 429   while (tag)
 430     {
 431       tree list;
 432       eh_catch n;
 433
 434       lto_tag_check_range (tag, LTO_eh_catch, LTO_eh_catch);
 435
 436       /* Read the catch node.  */
 437       n = ggc_alloc_cleared_eh_catch_d ();
 438       n->type_list = lto_input_tree (ib, data_in);
 439       n->filter_list = lto_input_tree (ib, data_in);
 440       n->label = lto_input_tree (ib, data_in);
 441
 442       /* Register all the types in N->FILTER_LIST.  */
 443       for (list = n->filter_list; list; list = TREE_CHAIN (list))
 444         add_type_for_runtime (TREE_VALUE (list));
 445
 446       /* Chain N to the end of the list.  */
 447       if (*last_p)
 448         (*last_p)->next_catch = n;
 449       n->prev_catch = *last_p;
 450       *last_p = n;
 451
 452       /* Set the head of the list the first time through the loop.  */
 453       if (first == NULL)
 454         first = n;
 455
 456       tag = input_record_start (ib);
 457     }
 458
 459   return first;
 460 }
 461
 462
 463 /* Read and return EH region IX from input block IB, using descriptors
 464    in DATA_IN.  */
 465
 466 static eh_region
 467 input_eh_region (struct lto_input_block *ib, struct data_in *data_in, int ix)
 468 {
 469   enum LTO_tags tag;
 470   eh_region r;
 471
 472   /* Read the region header.  */
 473   tag = input_record_start (ib);
 474   if (tag == LTO_null)
 475     return NULL;
 476
 477   r = ggc_alloc_cleared_eh_region_d ();
 478   r->index = lto_input_sleb128 (ib);
 479
 480   gcc_assert (r->index == ix);
 481
 482   /* Read all the region pointers as region numbers.  We'll fix up
 483      the pointers once the whole array has been read.  */
 484   r->outer = (eh_region) (intptr_t) lto_input_sleb128 (ib);
 485   r->inner = (eh_region) (intptr_t) lto_input_sleb128 (ib);
 486   r->next_peer = (eh_region) (intptr_t) lto_input_sleb128 (ib);
 487
 488   switch (tag)
 489     {
 490       case LTO_ert_cleanup:
 491         r->type = ERT_CLEANUP;
 492         break;
 493
 494       case LTO_ert_try:
 495         {
 496           struct eh_catch_d *last_catch;
 497           r->type = ERT_TRY;
 498           r->u.eh_try.first_catch = lto_input_eh_catch_list (ib, data_in,
 499                                                              &last_catch);
 500           r->u.eh_try.last_catch = last_catch;
 501           break;
 502         }
 503
 504       case LTO_ert_allowed_exceptions:
 505         {
 506           tree l;
 507
 508           r->type = ERT_ALLOWED_EXCEPTIONS;
 509           r->u.allowed.type_list = lto_input_tree (ib, data_in);
 510           r->u.allowed.label = lto_input_tree (ib, data_in);
 511           r->u.allowed.filter = lto_input_uleb128 (ib);
 512
 513           for (l = r->u.allowed.type_list; l ; l = TREE_CHAIN (l))
 514             add_type_for_runtime (TREE_VALUE (l));
 515         }
 516         break;
 517
 518       case LTO_ert_must_not_throw:
 519         r->type = ERT_MUST_NOT_THROW;
 520         r->u.must_not_throw.failure_decl = lto_input_tree (ib, data_in);
 521         r->u.must_not_throw.failure_loc = lto_input_location (ib, data_in);
 522         break;
 523
 524       default:
 525         gcc_unreachable ();
 526     }
 527
 528   r->landing_pads = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib);
 529
 530   return r;
 531 }
 532
 533
 534 /* Read and return EH landing pad IX from input block IB, using descriptors
 535    in DATA_IN.  */
 536
 537 static eh_landing_pad
 538 input_eh_lp (struct lto_input_block *ib, struct data_in *data_in, int ix)
 539 {
 540   enum LTO_tags tag;
 541   eh_landing_pad lp;
 542
 543   /* Read the landing pad header.  */
 544   tag = input_record_start (ib);
 545   if (tag == LTO_null)
 546     return NULL;
 547
 548   lto_tag_check_range (tag, LTO_eh_landing_pad, LTO_eh_landing_pad);
 549
 550   lp = ggc_alloc_cleared_eh_landing_pad_d ();
 551   lp->index = lto_input_sleb128 (ib);
 552   gcc_assert (lp->index == ix);
 553   lp->next_lp = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib);
 554   lp->region = (eh_region) (intptr_t) lto_input_sleb128 (ib);
 555   lp->post_landing_pad = lto_input_tree (ib, data_in);
 556
 557   return lp;
 558 }
 559
 560
 561 /* After reading the EH regions, pointers to peer and children regions
 562    are region numbers.  This converts all these region numbers into
 563    real pointers into the rematerialized regions for FN.  ROOT_REGION
 564    is the region number for the root EH region in FN.  */
 565
 566 static void
 567 fixup_eh_region_pointers (struct function *fn, HOST_WIDE_INT root_region)
 568 {
 569   unsigned i;
 570   VEC(eh_region,gc) *eh_array = fn->eh->region_array;
 571   VEC(eh_landing_pad,gc) *lp_array = fn->eh->lp_array;
 572   eh_region r;
 573   eh_landing_pad lp;
 574
 575   gcc_assert (eh_array && lp_array);
 576
 577   gcc_assert (root_region >= 0);
 578   fn->eh->region_tree = VEC_index (eh_region, eh_array, root_region);
 579
 580 #define FIXUP_EH_REGION(r) (r) = VEC_index (eh_region, eh_array, \
 581                                             (HOST_WIDE_INT) (intptr_t) (r))
 582 #define FIXUP_EH_LP(p) (p) = VEC_index (eh_landing_pad, lp_array, \
 583                                         (HOST_WIDE_INT) (intptr_t) (p))
 584
 585   /* Convert all the index numbers stored in pointer fields into
 586      pointers to the corresponding slots in the EH region array.  */
 587   FOR_EACH_VEC_ELT (eh_region, eh_array, i, r)
 588     {
 589       /* The array may contain NULL regions.  */
 590       if (r == NULL)
 591         continue;
 592
 593       gcc_assert (i == (unsigned) r->index);
 594       FIXUP_EH_REGION (r->outer);
 595       FIXUP_EH_REGION (r->inner);
 596       FIXUP_EH_REGION (r->next_peer);
 597       FIXUP_EH_LP (r->landing_pads);
 598     }
 599
 600   /* Convert all the index numbers stored in pointer fields into
 601      pointers to the corresponding slots in the EH landing pad array.  */
 602   FOR_EACH_VEC_ELT (eh_landing_pad, lp_array, i, lp)
 603     {
 604       /* The array may contain NULL landing pads.  */
 605       if (lp == NULL)
 606         continue;
 607
 608       gcc_assert (i == (unsigned) lp->index);
 609       FIXUP_EH_LP (lp->next_lp);
 610       FIXUP_EH_REGION (lp->region);
 611     }
 612
 613 #undef FIXUP_EH_REGION
 614 #undef FIXUP_EH_LP
 615 }
 616
 617
 618 /* Initialize EH support.  */
 619
 620 static void
 621 lto_init_eh (void)
 622 {
 623   static bool eh_initialized_p = false;
 624
 625   if (eh_initialized_p)
 626     return;
 627
 628   /* Contrary to most other FEs, we only initialize EH support when at
 629      least one of the files in the set contains exception regions in
 630      it.  Since this happens much later than the call to init_eh in
 631      lang_dependent_init, we have to set flag_exceptions and call
 632      init_eh again to initialize the EH tables.  */
 633   flag_exceptions = 1;
 634   init_eh ();
 635
 636   /* Initialize dwarf2 tables.  Since dwarf2out_do_frame() returns
 637      true only when exceptions are enabled, this initialization is
 638      never done during lang_dependent_init.  */
 639 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
 640   if (dwarf2out_do_frame ())
 641     dwarf2out_frame_init ();
 642 #endif
 643
 644   eh_initialized_p = true;
 645 }
 646
 647
 648 /* Read the exception table for FN from IB using the data descriptors
 649    in DATA_IN.  */
 650
 651 static void
 652 input_eh_regions (struct lto_input_block *ib, struct data_in *data_in,
 653                   struct function *fn)
 654 {
 655   HOST_WIDE_INT i, root_region, len;
 656   enum LTO_tags tag;
 657
 658   tag = input_record_start (ib);
 659   if (tag == LTO_null)
 660     return;
 661
 662   lto_tag_check_range (tag, LTO_eh_table, LTO_eh_table);
 663
 664   /* If the file contains EH regions, then it was compiled with
 665      -fexceptions.  In that case, initialize the backend EH
 666      machinery.  */
 667   lto_init_eh ();
 668
 669   gcc_assert (fn->eh);
 670
 671   root_region = lto_input_sleb128 (ib);
 672   gcc_assert (root_region == (int) root_region);
 673
 674   /* Read the EH region array.  */
 675   len = lto_input_sleb128 (ib);
 676   gcc_assert (len == (int) len);
 677   if (len > 0)
 678     {
 679       VEC_safe_grow (eh_region, gc, fn->eh->region_array, len);
 680       for (i = 0; i < len; i++)
 681         {
 682           eh_region r = input_eh_region (ib, data_in, i);
 683           VEC_replace (eh_region, fn->eh->region_array, i, r);
 684         }
 685     }
 686
 687   /* Read the landing pads.  */
 688   len = lto_input_sleb128 (ib);
 689   gcc_assert (len == (int) len);
 690   if (len > 0)
 691     {
 692       VEC_safe_grow (eh_landing_pad, gc, fn->eh->lp_array, len);
 693       for (i = 0; i < len; i++)
 694         {
 695           eh_landing_pad lp = input_eh_lp (ib, data_in, i);
 696           VEC_replace (eh_landing_pad, fn->eh->lp_array, i, lp);
 697         }
 698     }
 699
 700   /* Read the runtime type data.  */
 701   len = lto_input_sleb128 (ib);
 702   gcc_assert (len == (int) len);
 703   if (len > 0)
 704     {
 705       VEC_safe_grow (tree, gc, fn->eh->ttype_data, len);
 706       for (i = 0; i < len; i++)
 707         {
 708           tree ttype = lto_input_tree (ib, data_in);
 709           VEC_replace (tree, fn->eh->ttype_data, i, ttype);
 710         }
 711     }
 712
 713   /* Read the table of action chains.  */
 714   len = lto_input_sleb128 (ib);
 715   gcc_assert (len == (int) len);
 716   if (len > 0)
 717     {
 718       if (targetm.arm_eabi_unwinder)
 719         {
 720           VEC_safe_grow (tree, gc, fn->eh->ehspec_data.arm_eabi, len);
 721           for (i = 0; i < len; i++)
 722             {
 723               tree t = lto_input_tree (ib, data_in);
 724               VEC_replace (tree, fn->eh->ehspec_data.arm_eabi, i, t);
 725             }
 726         }
 727       else
 728         {
 729           VEC_safe_grow (uchar, gc, fn->eh->ehspec_data.other, len);
 730           for (i = 0; i < len; i++)
 731             {
 732               uchar c = lto_input_1_unsigned (ib);
 733               VEC_replace (uchar, fn->eh->ehspec_data.other, i, c);
 734             }
 735         }
 736     }
 737
 738   /* Reconstruct the EH region tree by fixing up the peer/children
 739      pointers.  */
 740   fixup_eh_region_pointers (fn, root_region);
 741
 742   tag = input_record_start (ib);
 743   lto_tag_check_range (tag, LTO_null, LTO_null);
 744 }
 745
 746
 747 /* Make a new basic block with index INDEX in function FN.  */
 748
 749 static basic_block
 750 make_new_block (struct function *fn, unsigned int index)
 751 {
 752   basic_block bb = alloc_block ();
 753   bb->index = index;
 754   SET_BASIC_BLOCK_FOR_FUNCTION (fn, index, bb);
 755   bb->il.gimple = ggc_alloc_cleared_gimple_bb_info ();
 756   n_basic_blocks_for_function (fn)++;
 757   bb->flags = 0;
 758   set_bb_seq (bb, gimple_seq_alloc ());
 759   return bb;
 760 }
 761
 762
 763 /* Read the CFG for function FN from input block IB.  */
 764
 765 static void
 766 input_cfg (struct lto_input_block *ib, struct function *fn,
 767            int count_materialization_scale)
 768 {
 769   unsigned int bb_count;
 770   basic_block p_bb;
 771   unsigned int i;
 772   int index;
 773
 774   init_empty_tree_cfg_for_function (fn);
 775   init_ssa_operands ();
 776
 777   profile_status_for_function (fn) =
 778     (enum profile_status_d) lto_input_uleb128 (ib);
 779
 780   bb_count = lto_input_uleb128 (ib);
 781
 782   last_basic_block_for_function (fn) = bb_count;
 783   if (bb_count > VEC_length (basic_block, basic_block_info_for_function (fn)))
 784     VEC_safe_grow_cleared (basic_block, gc,
 785                            basic_block_info_for_function (fn), bb_count);
 786
 787   if (bb_count > VEC_length (basic_block, label_to_block_map_for_function (fn)))
 788     VEC_safe_grow_cleared (basic_block, gc,
 789                            label_to_block_map_for_function (fn), bb_count);
 790
 791   index = lto_input_sleb128 (ib);
 792   while (index != -1)
 793     {
 794       basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
 795       unsigned int edge_count;
 796
 797       if (bb == NULL)
 798         bb = make_new_block (fn, index);
 799
 800       edge_count = lto_input_uleb128 (ib);
 801
 802       /* Connect up the CFG.  */
 803       for (i = 0; i < edge_count; i++)
 804         {
 805           unsigned int dest_index;
 806           unsigned int edge_flags;
 807           basic_block dest;
 808           int probability;
 809           gcov_type count;
 810           edge e;
 811
 812           dest_index = lto_input_uleb128 (ib);
 813           probability = (int) lto_input_sleb128 (ib);
 814           count = ((gcov_type) lto_input_sleb128 (ib) * count_materialization_scale
 815                    + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE;
 816           edge_flags = lto_input_uleb128 (ib);
 817
 818           dest = BASIC_BLOCK_FOR_FUNCTION (fn, dest_index);
 819
 820           if (dest == NULL)
 821             dest = make_new_block (fn, dest_index);
 822
 823           e = make_edge (bb, dest, edge_flags);
 824           e->probability = probability;
 825           e->count = count;
 826         }
 827
 828       index = lto_input_sleb128 (ib);
 829     }
 830
 831   p_bb = ENTRY_BLOCK_PTR_FOR_FUNCTION(fn);
 832   index = lto_input_sleb128 (ib);
 833   while (index != -1)
 834     {
 835       basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
 836       bb->prev_bb = p_bb;
 837       p_bb->next_bb = bb;
 838       p_bb = bb;
 839       index = lto_input_sleb128 (ib);
 840     }
 841 }
 842
 843
 844 /* Read a PHI function for basic block BB in function FN.  DATA_IN is
 845    the file being read.  IB is the input block to use for reading.  */
 846
 847 static gimple
 848 input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in,
 849            struct function *fn)
 850 {
 851   unsigned HOST_WIDE_INT ix;
 852   tree phi_result;
 853   int i, len;
 854   gimple result;
 855
 856   ix = lto_input_uleb128 (ib);
 857   phi_result = VEC_index (tree, SSANAMES (fn), ix);
 858   len = EDGE_COUNT (bb->preds);
 859   result = create_phi_node (phi_result, bb);
 860   SSA_NAME_DEF_STMT (phi_result) = result;
 861
 862   /* We have to go through a lookup process here because the preds in the
 863      reconstructed graph are generally in a different order than they
 864      were in the original program.  */
 865   for (i = 0; i < len; i++)
 866     {
 867       tree def = lto_input_tree (ib, data_in);
 868       int src_index = lto_input_uleb128 (ib);
 869       location_t arg_loc = lto_input_location (ib, data_in);
 870       basic_block sbb = BASIC_BLOCK_FOR_FUNCTION (fn, src_index);
 871
 872       edge e = NULL;
 873       int j;
 874
 875       for (j = 0; j < len; j++)
 876         if (EDGE_PRED (bb, j)->src == sbb)
 877           {
 878             e = EDGE_PRED (bb, j);
 879             break;
 880           }
 881
 882       add_phi_arg (result, def, e, arg_loc);
 883     }
 884
 885   return result;
 886 }
 887
 888
 889 /* Read the SSA names array for function FN from DATA_IN using input
 890    block IB.  */
 891
 892 static void
 893 input_ssa_names (struct lto_input_block *ib, struct data_in *data_in,
 894                  struct function *fn)
 895 {
 896   unsigned int i, size;
 897
 898   size = lto_input_uleb128 (ib);
 899   init_ssanames (fn, size);
 900
 901   i = lto_input_uleb128 (ib);
 902   while (i)
 903     {
 904       tree ssa_name, name;
 905       bool is_default_def;
 906
 907       /* Skip over the elements that had been freed.  */
 908       while (VEC_length (tree, SSANAMES (fn)) < i)
 909         VEC_quick_push (tree, SSANAMES (fn), NULL_TREE);
 910
 911       is_default_def = (lto_input_1_unsigned (ib) != 0);
 912       name = lto_input_tree (ib, data_in);
 913       ssa_name = make_ssa_name_fn (fn, name, gimple_build_nop ());
 914
 915       if (is_default_def)
 916         set_default_def (SSA_NAME_VAR (ssa_name), ssa_name);
 917
 918       i = lto_input_uleb128 (ib);
 919     }
 920 }
 921
 922 /* Read a statement with tag TAG in function FN from block IB using
 923    descriptors in DATA_IN.  */
 924
 925 static gimple
 926 input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
 927                    struct function *fn, enum LTO_tags tag)
 928 {
 929   gimple stmt;
 930   enum gimple_code code;
 931   unsigned HOST_WIDE_INT num_ops;
 932   size_t i;
 933   struct bitpack_d bp;
 934
 935   code = lto_tag_to_gimple_code (tag);
 936
 937   /* Read the tuple header.  */
 938   bp = lto_input_bitpack (ib);
 939   num_ops = bp_unpack_value (&bp, sizeof (unsigned) * 8);
 940   stmt = gimple_alloc (code, num_ops);
 941   stmt->gsbase.no_warning = bp_unpack_value (&bp, 1);
 942   if (is_gimple_assign (stmt))
 943     stmt->gsbase.nontemporal_move = bp_unpack_value (&bp, 1);
 944   stmt->gsbase.has_volatile_ops = bp_unpack_value (&bp, 1);
 945   stmt->gsbase.subcode = bp_unpack_value (&bp, 16);
 946
 947   /* Read location information.  */
 948   gimple_set_location (stmt, lto_input_location (ib, data_in));
 949
 950   /* Read lexical block reference.  */
 951   gimple_set_block (stmt, lto_input_tree (ib, data_in));
 952
 953   /* Read in all the operands.  */
 954   switch (code)
 955     {
 956     case GIMPLE_RESX:
 957       gimple_resx_set_region (stmt, lto_input_sleb128 (ib));
 958       break;
 959
 960     case GIMPLE_EH_MUST_NOT_THROW:
 961       gimple_eh_must_not_throw_set_fndecl (stmt, lto_input_tree (ib, data_in));
 962       break;
 963
 964     case GIMPLE_EH_DISPATCH:
 965       gimple_eh_dispatch_set_region (stmt, lto_input_sleb128 (ib));
 966       break;
 967
 968     case GIMPLE_ASM:
 969       {
 970         /* FIXME lto.  Move most of this into a new gimple_asm_set_string().  */
 971         tree str;
 972         stmt->gimple_asm.ni = lto_input_uleb128 (ib);
 973         stmt->gimple_asm.no = lto_input_uleb128 (ib);
 974         stmt->gimple_asm.nc = lto_input_uleb128 (ib);
 975         stmt->gimple_asm.nl = lto_input_uleb128 (ib);
 976         str = input_string_cst (data_in, ib);
 977         stmt->gimple_asm.string = TREE_STRING_POINTER (str);
 978       }
 979       /* Fallthru  */
 980
 981     case GIMPLE_ASSIGN:
 982     case GIMPLE_CALL:
 983     case GIMPLE_RETURN:
 984     case GIMPLE_SWITCH:
 985     case GIMPLE_LABEL:
 986     case GIMPLE_COND:
 987     case GIMPLE_GOTO:
 988     case GIMPLE_DEBUG:
 989       for (i = 0; i < num_ops; i++)
 990         {
 991           tree op = lto_input_tree (ib, data_in);
 992           gimple_set_op (stmt, i, op);
 993           if (!op)
 994             continue;
 995
 996           /* Fixup FIELD_DECLs in COMPONENT_REFs, they are not handled
 997              by decl merging.  */
 998           if (TREE_CODE (op) == ADDR_EXPR)
 999             op = TREE_OPERAND (op, 0);
1000           while (handled_component_p (op))
1001             {
1002               if (TREE_CODE (op) == COMPONENT_REF)
1003                 {
1004                   tree field, type, tem;
1005                   tree closest_match = NULL_TREE;
1006                   field = TREE_OPERAND (op, 1);
1007                   type = DECL_CONTEXT (field);
1008                   for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1009                     {
1010                       if (tem == field)
1011                         break;
1012                       if (DECL_NONADDRESSABLE_P (tem)
1013                           == DECL_NONADDRESSABLE_P (field)
1014                           && gimple_compare_field_offset (tem, field))
1015                         {
1016                           if (types_compatible_p (TREE_TYPE (tem),
1017                                                   TREE_TYPE (field)))
1018                             break;
1019                           else
1020                             closest_match = tem;
1021                         }
1022                     }
1023                   /* In case of type mismatches across units we can fail
1024                      to unify some types and thus not find a proper
1025                      field-decl here.  */
1026                   if (tem == NULL_TREE)
1027                     {
1028                       /* Thus, emit a ODR violation warning.  */
1029                       if (warning_at (gimple_location (stmt), 0,
1030                                       "use of type %<%E%> with two mismatching "
1031                                       "declarations at field %<%E%>",
1032                                       type, TREE_OPERAND (op, 1)))
1033                         {
1034                           if (TYPE_FIELDS (type))
1035                             inform (DECL_SOURCE_LOCATION (TYPE_FIELDS (type)),
1036                                     "original type declared here");
1037                           inform (DECL_SOURCE_LOCATION (TREE_OPERAND (op, 1)),
1038                                   "field in mismatching type declared here");
1039                           if (TYPE_NAME (TREE_TYPE (field))
1040                               && (TREE_CODE (TYPE_NAME (TREE_TYPE (field)))
1041                                   == TYPE_DECL))
1042                             inform (DECL_SOURCE_LOCATION
1043                                       (TYPE_NAME (TREE_TYPE (field))),
1044                                     "type of field declared here");
1045                           if (closest_match
1046                               && TYPE_NAME (TREE_TYPE (closest_match))
1047                               && (TREE_CODE (TYPE_NAME
1048                                    (TREE_TYPE (closest_match))) == TYPE_DECL))
1049                             inform (DECL_SOURCE_LOCATION
1050                                       (TYPE_NAME (TREE_TYPE (closest_match))),
1051                                     "type of mismatching field declared here");
1052                         }
1053                       /* And finally fixup the types.  */
1054                       TREE_OPERAND (op, 0)
1055                         = build1 (VIEW_CONVERT_EXPR, type,
1056                                   TREE_OPERAND (op, 0));
1057                     }
1058                   else
1059                     TREE_OPERAND (op, 1) = tem;
1060                 }
1061
1062               op = TREE_OPERAND (op, 0);
1063             }
1064         }
1065       break;
1066
1067     case GIMPLE_NOP:
1068     case GIMPLE_PREDICT:
1069       break;
1070
1071     default:
1072       internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
1073                       lto_tag_name (tag));
1074     }
1075
1076   /* Update the properties of symbols, SSA names and labels associated
1077      with STMT.  */
1078   if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
1079     {
1080       tree lhs = gimple_get_lhs (stmt);
1081       if (lhs && TREE_CODE (lhs) == SSA_NAME)
1082         SSA_NAME_DEF_STMT (lhs) = stmt;
1083     }
1084   else if (code == GIMPLE_LABEL)
1085     gcc_assert (emit_label_in_global_context_p (gimple_label_label (stmt))
1086                 || DECL_CONTEXT (gimple_label_label (stmt)) == fn->decl);
1087   else if (code == GIMPLE_ASM)
1088     {
1089       unsigned i;
1090
1091       for (i = 0; i < gimple_asm_noutputs (stmt); i++)
1092         {
1093           tree op = TREE_VALUE (gimple_asm_output_op (stmt, i));
1094           if (TREE_CODE (op) == SSA_NAME)
1095             SSA_NAME_DEF_STMT (op) = stmt;
1096         }
1097     }
1098
1099   /* Reset alias information.  */
1100   if (code == GIMPLE_CALL)
1101     gimple_call_reset_alias_info (stmt);
1102
1103   /* Mark the statement modified so its operand vectors can be filled in.  */
1104   gimple_set_modified (stmt, true);
1105
1106   return stmt;
1107 }
1108
1109
1110 /* Read a basic block with tag TAG from DATA_IN using input block IB.
1111    FN is the function being processed.  */
1112
1113 static void
1114 input_bb (struct lto_input_block *ib, enum LTO_tags tag,
1115           struct data_in *data_in, struct function *fn,
1116           int count_materialization_scale)
1117 {
1118   unsigned int index;
1119   basic_block bb;
1120   gimple_stmt_iterator bsi;
1121
1122   /* This routine assumes that CFUN is set to FN, as it needs to call
1123      basic GIMPLE routines that use CFUN.  */
1124   gcc_assert (cfun == fn);
1125
1126   index = lto_input_uleb128 (ib);
1127   bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
1128
1129   bb->count = (lto_input_sleb128 (ib) * count_materialization_scale
1130                + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE;
1131   bb->loop_depth = lto_input_sleb128 (ib);
1132   bb->frequency = lto_input_sleb128 (ib);
1133   bb->flags = lto_input_sleb128 (ib);
1134
1135   /* LTO_bb1 has statements.  LTO_bb0 does not.  */
1136   if (tag == LTO_bb0)
1137     return;
1138
1139   bsi = gsi_start_bb (bb);
1140   tag = input_record_start (ib);
1141   while (tag)
1142     {
1143       gimple stmt = input_gimple_stmt (ib, data_in, fn, tag);
1144       if (!is_gimple_debug (stmt))
1145         find_referenced_vars_in (stmt);
1146       gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1147
1148       /* After the statement, expect a 0 delimiter or the EH region
1149          that the previous statement belongs to.  */
1150       tag = input_record_start (ib);
1151       lto_tag_check_set (tag, 2, LTO_eh_region, LTO_null);
1152
1153       if (tag == LTO_eh_region)
1154         {
1155           HOST_WIDE_INT region = lto_input_sleb128 (ib);
1156           gcc_assert (region == (int) region);
1157           add_stmt_to_eh_lp (stmt, region);
1158         }
1159
1160       tag = input_record_start (ib);
1161     }
1162
1163   tag = input_record_start (ib);
1164   while (tag)
1165     {
1166       gimple phi = input_phi (ib, bb, data_in, fn);
1167       find_referenced_vars_in (phi);
1168       tag = input_record_start (ib);
1169     }
1170 }
1171
1172 /* Go through all NODE edges and fixup call_stmt pointers
1173    so they point to STMTS.  */
1174
1175 static void
1176 fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple *stmts)
1177 {
1178   struct cgraph_edge *cedge;
1179   for (cedge = node->callees; cedge; cedge = cedge->next_callee)
1180     cedge->call_stmt = stmts[cedge->lto_stmt_uid];
1181   for (cedge = node->indirect_calls; cedge; cedge = cedge->next_callee)
1182     cedge->call_stmt = stmts[cedge->lto_stmt_uid];
1183 }
1184
1185 /* Fixup call_stmt pointers in NODE and all clones.  */
1186
1187 static void
1188 fixup_call_stmt_edges (struct cgraph_node *orig, gimple *stmts)
1189 {
1190   struct cgraph_node *node;
1191
1192   while (orig->clone_of)
1193     orig = orig->clone_of;
1194
1195   fixup_call_stmt_edges_1 (orig, stmts);
1196   if (orig->clones)
1197     for (node = orig->clones; node != orig;)
1198       {
1199         fixup_call_stmt_edges_1 (node, stmts);
1200         if (node->clones)
1201           node = node->clones;
1202         else if (node->next_sibling_clone)
1203           node = node->next_sibling_clone;
1204         else
1205           {
1206             while (node != orig && !node->next_sibling_clone)
1207               node = node->clone_of;
1208             if (node != orig)
1209               node = node->next_sibling_clone;
1210           }
1211       }
1212 }
1213
1214 /* Read the body of function FN_DECL from DATA_IN using input block IB.  */
1215
1216 static void
1217 input_function (tree fn_decl, struct data_in *data_in,
1218                 struct lto_input_block *ib)
1219 {
1220   struct function *fn;
1221   enum LTO_tags tag;
1222   gimple *stmts;
1223   basic_block bb;
1224   struct bitpack_d bp;
1225   struct cgraph_node *node;
1226   tree args, narg, oarg;
1227   int len;
1228
1229   fn = DECL_STRUCT_FUNCTION (fn_decl);
1230   tag = input_record_start (ib);
1231   clear_line_info (data_in);
1232
1233   gimple_register_cfg_hooks ();
1234   lto_tag_check (tag, LTO_function);
1235
1236   /* Read all the attributes for FN.  */
1237   bp = lto_input_bitpack (ib);
1238   fn->is_thunk = bp_unpack_value (&bp, 1);
1239   fn->has_local_explicit_reg_vars = bp_unpack_value (&bp, 1);
1240   fn->after_tree_profile = bp_unpack_value (&bp, 1);
1241   fn->returns_pcc_struct = bp_unpack_value (&bp, 1);
1242   fn->returns_struct = bp_unpack_value (&bp, 1);
1243   fn->can_throw_non_call_exceptions = bp_unpack_value (&bp, 1);
1244   fn->always_inline_functions_inlined = bp_unpack_value (&bp, 1);
1245   fn->after_inlining = bp_unpack_value (&bp, 1);
1246   fn->dont_save_pending_sizes_p = bp_unpack_value (&bp, 1);
1247   fn->stdarg = bp_unpack_value (&bp, 1);
1248   fn->has_nonlocal_label = bp_unpack_value (&bp, 1);
1249   fn->calls_alloca = bp_unpack_value (&bp, 1);
1250   fn->calls_setjmp = bp_unpack_value (&bp, 1);
1251   fn->va_list_fpr_size = bp_unpack_value (&bp, 8);
1252   fn->va_list_gpr_size = bp_unpack_value (&bp, 8);
1253
1254   /* Input the function start and end loci.  */
1255   fn->function_start_locus = lto_input_location (ib, data_in);
1256   fn->function_end_locus = lto_input_location (ib, data_in);
1257
1258   /* Input the current IL state of the function.  */
1259   fn->curr_properties = lto_input_uleb128 (ib);
1260
1261   /* Read the static chain and non-local goto save area.  */
1262   fn->static_chain_decl = lto_input_tree (ib, data_in);
1263   fn->nonlocal_goto_save_area = lto_input_tree (ib, data_in);
1264
1265   /* Read all the local symbols.  */
1266   len = lto_input_sleb128 (ib);
1267   if (len > 0)
1268     {
1269       int i;
1270       VEC_safe_grow (tree, gc, fn->local_decls, len);
1271       for (i = 0; i < len; i++)
1272         {
1273           tree t = lto_input_tree (ib, data_in);
1274           VEC_replace (tree, fn->local_decls, i, t);
1275         }
1276     }
1277
1278   /* Read all function arguments.  We need to re-map them here to the
1279      arguments of the merged function declaration.  */
1280   args = lto_input_tree (ib, data_in);
1281   for (oarg = args, narg = DECL_ARGUMENTS (fn_decl);
1282        oarg && narg;
1283        oarg = TREE_CHAIN (oarg), narg = TREE_CHAIN (narg))
1284     {
1285       unsigned ix;
1286       bool res;
1287       res = lto_streamer_cache_lookup (data_in->reader_cache, oarg, &ix);
1288       gcc_assert (res);
1289       /* Replace the argument in the streamer cache.  */
1290       lto_streamer_cache_insert_at (data_in->reader_cache, narg, ix);
1291     }
1292   gcc_assert (!oarg && !narg);
1293
1294   /* Read all the SSA names.  */
1295   input_ssa_names (ib, data_in, fn);
1296
1297   /* Read the exception handling regions in the function.  */
1298   input_eh_regions (ib, data_in, fn);
1299
1300   /* Read the tree of lexical scopes for the function.  */
1301   DECL_INITIAL (fn_decl) = lto_input_tree (ib, data_in);
1302   gcc_assert (DECL_INITIAL (fn_decl));
1303   DECL_SAVED_TREE (fn_decl) = NULL_TREE;
1304   node = cgraph_node (fn_decl);
1305
1306   /* Read all the basic blocks.  */
1307   tag = input_record_start (ib);
1308   while (tag)
1309     {
1310       input_bb (ib, tag, data_in, fn,
1311                 node->count_materialization_scale);
1312       tag = input_record_start (ib);
1313     }
1314
1315   /* Fix up the call statements that are mentioned in the callgraph
1316      edges.  */
1317   set_gimple_stmt_max_uid (cfun, 0);
1318   FOR_ALL_BB (bb)
1319     {
1320       gimple_stmt_iterator gsi;
1321       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1322         {
1323           gimple stmt = gsi_stmt (gsi);
1324           gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
1325         }
1326     }
1327   stmts = (gimple *) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple));
1328   FOR_ALL_BB (bb)
1329     {
1330       gimple_stmt_iterator bsi = gsi_start_bb (bb);
1331       while (!gsi_end_p (bsi))
1332         {
1333           gimple stmt = gsi_stmt (bsi);
1334           /* If we're recompiling LTO objects with debug stmts but
1335              we're not supposed to have debug stmts, remove them now.
1336              We can't remove them earlier because this would cause uid
1337              mismatches in fixups, but we can do it at this point, as
1338              long as debug stmts don't require fixups.  */
1339           if (!MAY_HAVE_DEBUG_STMTS && is_gimple_debug (stmt))
1340             {
1341               gimple_stmt_iterator gsi = bsi;
1342               gsi_next (&bsi);
1343               gsi_remove (&gsi, true);
1344             }
1345           else
1346             {
1347               gsi_next (&bsi);
1348               stmts[gimple_uid (stmt)] = stmt;
1349             }
1350         }
1351     }
1352
1353   /* Set the gimple body to the statement sequence in the entry
1354      basic block.  FIXME lto, this is fairly hacky.  The existence
1355      of a gimple body is used by the cgraph routines, but we should
1356      really use the presence of the CFG.  */
1357   {
1358     edge_iterator ei = ei_start (ENTRY_BLOCK_PTR->succs);
1359     gimple_set_body (fn_decl, bb_seq (ei_edge (ei)->dest));
1360   }
1361
1362   fixup_call_stmt_edges (node, stmts);
1363   execute_all_ipa_stmt_fixups (node, stmts);
1364
1365   update_ssa (TODO_update_ssa_only_virtuals);
1366   free_dominance_info (CDI_DOMINATORS);
1367   free_dominance_info (CDI_POST_DOMINATORS);
1368   free (stmts);
1369 }
1370
1371
1372 /* Read initializer expressions for public statics.  DATA_IN is the
1373    file being read.  IB is the input block used for reading.  */
1374
1375 static void
1376 input_alias_pairs (struct lto_input_block *ib, struct data_in *data_in)
1377 {
1378   tree var;
1379
1380   clear_line_info (data_in);
1381
1382   var = lto_input_tree (ib, data_in);
1383   while (var)
1384     {
1385       const char *orig_name, *new_name;
1386       alias_pair *p;
1387
1388       p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
1389       p->decl = var;
1390       p->target = lto_input_tree (ib, data_in);
1391
1392       /* If the target is a static object, we may have registered a
1393          new name for it to avoid clashes between statics coming from
1394          different files.  In that case, use the new name.  */
1395       orig_name = IDENTIFIER_POINTER (p->target);
1396       new_name = lto_get_decl_name_mapping (data_in->file_data, orig_name);
1397       if (strcmp (orig_name, new_name) != 0)
1398         p->target = get_identifier (new_name);
1399
1400       var = lto_input_tree (ib, data_in);
1401     }
1402 }
1403
1404
1405 /* Read the body from DATA for function FN_DECL and fill it in.
1406    FILE_DATA are the global decls and types.  SECTION_TYPE is either
1407    LTO_section_function_body or LTO_section_static_initializer.  If
1408    section type is LTO_section_function_body, FN must be the decl for
1409    that function.  */
1410
1411 static void
1412 lto_read_body (struct lto_file_decl_data *file_data, tree fn_decl,
1413                const char *data, enum lto_section_type section_type)
1414 {
1415   const struct lto_function_header *header;
1416   struct data_in *data_in;
1417   int32_t cfg_offset;
1418   int32_t main_offset;
1419   int32_t string_offset;
1420   struct lto_input_block ib_cfg;
1421   struct lto_input_block ib_main;
1422
1423   header = (const struct lto_function_header *) data;
1424   cfg_offset = sizeof (struct lto_function_header);
1425   main_offset = cfg_offset + header->cfg_size;
1426   string_offset = main_offset + header->main_size;
1427
1428   LTO_INIT_INPUT_BLOCK (ib_cfg,
1429                         data + cfg_offset,
1430                         0,
1431                         header->cfg_size);
1432
1433   LTO_INIT_INPUT_BLOCK (ib_main,
1434                         data + main_offset,
1435                         0,
1436                         header->main_size);
1437
1438   data_in = lto_data_in_create (file_data, data + string_offset,
1439                                 header->string_size, NULL);
1440
1441   /* Make sure the file was generated by the exact same compiler.  */
1442   lto_check_version (header->lto_header.major_version,
1443                      header->lto_header.minor_version);
1444
1445   if (section_type == LTO_section_function_body)
1446     {
1447       struct function *fn = DECL_STRUCT_FUNCTION (fn_decl);
1448       struct lto_in_decl_state *decl_state;
1449       struct cgraph_node *node = cgraph_node (fn_decl);
1450
1451       push_cfun (fn);
1452       init_tree_ssa (fn);
1453
1454       /* Use the function's decl state. */
1455       decl_state = lto_get_function_in_decl_state (file_data, fn_decl);
1456       gcc_assert (decl_state);
1457       file_data->current_decl_state = decl_state;
1458
1459       input_cfg (&ib_cfg, fn, node->count_materialization_scale);
1460
1461       /* Set up the struct function.  */
1462       input_function (fn_decl, data_in, &ib_main);
1463
1464       /* We should now be in SSA.  */
1465       cfun->gimple_df->in_ssa_p = true;
1466
1467       /* Restore decl state */
1468       file_data->current_decl_state = file_data->global_decl_state;
1469
1470       pop_cfun ();
1471     }
1472   else
1473     {
1474       input_alias_pairs (&ib_main, data_in);
1475     }
1476
1477   clear_line_info (data_in);
1478   lto_data_in_delete (data_in);
1479 }
1480
1481
1482 /* Read the body of FN_DECL using DATA.  FILE_DATA holds the global
1483    decls and types.  */
1484
1485 void
1486 lto_input_function_body (struct lto_file_decl_data *file_data,
1487                          tree fn_decl, const char *data)
1488 {
1489   current_function_decl = fn_decl;
1490   lto_read_body (file_data, fn_decl, data, LTO_section_function_body);
1491 }
1492
1493
1494 /* Read in VAR_DECL using DATA.  FILE_DATA holds the global decls and
1495    types.  */
1496
1497 void
1498 lto_input_constructors_and_inits (struct lto_file_decl_data *file_data,
1499                                   const char *data)
1500 {
1501   lto_read_body (file_data, NULL, data, LTO_section_static_initializer);
1502 }
1503
1504
1505 /* Return the resolution for the decl with index INDEX from DATA_IN. */
1506
1507 static enum ld_plugin_symbol_resolution
1508 get_resolution (struct data_in *data_in, unsigned index)
1509 {
1510   if (data_in->globals_resolution)
1511     {
1512       ld_plugin_symbol_resolution_t ret;
1513       /* We can have references to not emitted functions in
1514          DECL_FUNCTION_PERSONALITY at least.  So we can and have
1515          to indeed return LDPR_UNKNOWN in some cases.   */
1516       if (VEC_length (ld_plugin_symbol_resolution_t,
1517                       data_in->globals_resolution) <= index)
1518         return LDPR_UNKNOWN;
1519       ret = VEC_index (ld_plugin_symbol_resolution_t,
1520                        data_in->globals_resolution,
1521                        index);
1522       return ret;
1523     }
1524   else
1525     /* Delay resolution finding until decl merging.  */
1526     return LDPR_UNKNOWN;
1527 }
1528
1529
1530 /* Unpack all the non-pointer fields of the TS_BASE structure of
1531    expression EXPR from bitpack BP.  */
1532
1533 static void
1534 unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
1535 {
1536   /* Note that the code for EXPR has already been unpacked to create EXPR in
1537      lto_materialize_tree.  */
1538   if (!TYPE_P (expr))
1539     {
1540       TREE_SIDE_EFFECTS (expr) = (unsigned) bp_unpack_value (bp, 1);
1541       TREE_CONSTANT (expr) = (unsigned) bp_unpack_value (bp, 1);
1542       TREE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1543
1544       /* TREE_PUBLIC is used on types to indicate that the type
1545          has a TYPE_CACHED_VALUES vector.  This is not streamed out,
1546          so we skip it here.  */
1547       TREE_PUBLIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1548     }
1549   else
1550     bp_unpack_value (bp, 4);
1551   TREE_ADDRESSABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1552   TREE_THIS_VOLATILE (expr) = (unsigned) bp_unpack_value (bp, 1);
1553   if (DECL_P (expr))
1554     DECL_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1555   else if (TYPE_P (expr))
1556     TYPE_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1557   else
1558     bp_unpack_value (bp, 1);
1559   TREE_ASM_WRITTEN (expr) = (unsigned) bp_unpack_value (bp, 1);
1560   TREE_NO_WARNING (expr) = (unsigned) bp_unpack_value (bp, 1);
1561   TREE_USED (expr) = (unsigned) bp_unpack_value (bp, 1);
1562   TREE_NOTHROW (expr) = (unsigned) bp_unpack_value (bp, 1);
1563   TREE_STATIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1564   TREE_PRIVATE (expr) = (unsigned) bp_unpack_value (bp, 1);
1565   TREE_PROTECTED (expr) = (unsigned) bp_unpack_value (bp, 1);
1566   TREE_DEPRECATED (expr) = (unsigned) bp_unpack_value (bp, 1);
1567   if (TYPE_P (expr))
1568     TYPE_SATURATING (expr) = (unsigned) bp_unpack_value (bp, 1);
1569   else if (TREE_CODE (expr) == SSA_NAME)
1570     SSA_NAME_IS_DEFAULT_DEF (expr) = (unsigned) bp_unpack_value (bp, 1);
1571   else
1572     bp_unpack_value (bp, 1);
1573 }
1574
1575
1576 /* Unpack all the non-pointer fields of the TS_REAL_CST structure of
1577    expression EXPR from bitpack BP.  */
1578
1579 static void
1580 unpack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
1581 {
1582   unsigned i;
1583   REAL_VALUE_TYPE r;
1584   REAL_VALUE_TYPE *rp;
1585
1586   r.cl = (unsigned) bp_unpack_value (bp, 2);
1587   r.decimal = (unsigned) bp_unpack_value (bp, 1);
1588   r.sign = (unsigned) bp_unpack_value (bp, 1);
1589   r.signalling = (unsigned) bp_unpack_value (bp, 1);
1590   r.canonical = (unsigned) bp_unpack_value (bp, 1);
1591   r.uexp = (unsigned) bp_unpack_value (bp, EXP_BITS);
1592   for (i = 0; i < SIGSZ; i++)
1593     r.sig[i] = (unsigned long) bp_unpack_value (bp, HOST_BITS_PER_LONG);
1594
1595   rp = ggc_alloc_real_value ();
1596   memcpy (rp, &r, sizeof (REAL_VALUE_TYPE));
1597   TREE_REAL_CST_PTR (expr) = rp;
1598 }
1599
1600
1601 /* Unpack all the non-pointer fields of the TS_FIXED_CST structure of
1602    expression EXPR from bitpack BP.  */
1603
1604 static void
1605 unpack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
1606 {
1607   struct fixed_value fv;
1608
1609   fv.data.low = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1610   fv.data.high = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1611   fv.mode = (enum machine_mode) bp_unpack_value (bp, HOST_BITS_PER_INT);
1612   TREE_FIXED_CST (expr) = fv;
1613 }
1614
1615
1616 /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure
1617    of expression EXPR from bitpack BP.  */
1618
1619 static void
1620 unpack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
1621 {
1622   DECL_MODE (expr) = (enum machine_mode) bp_unpack_value (bp, 8);
1623   DECL_NONLOCAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1624   DECL_VIRTUAL_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1625   DECL_IGNORED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1626   DECL_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1627   DECL_ARTIFICIAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1628   DECL_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1629   DECL_PRESERVE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1630   DECL_DEBUG_EXPR_IS_FROM (expr) = (unsigned) bp_unpack_value (bp, 1);
1631   DECL_EXTERNAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1632   DECL_GIMPLE_REG_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1633   DECL_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1634
1635   if (TREE_CODE (expr) == LABEL_DECL)
1636     {
1637       DECL_ERROR_ISSUED (expr) = (unsigned) bp_unpack_value (bp, 1);
1638       EH_LANDING_PAD_NR (expr) = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
1639
1640       /* Always assume an initial value of -1 for LABEL_DECL_UID to
1641          force gimple_set_bb to recreate label_to_block_map.  */
1642       LABEL_DECL_UID (expr) = -1;
1643     }
1644
1645   if (TREE_CODE (expr) == FIELD_DECL)
1646     {
1647       unsigned HOST_WIDE_INT off_align;
1648       DECL_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1649       DECL_NONADDRESSABLE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1650       off_align = (unsigned HOST_WIDE_INT) bp_unpack_value (bp, 8);
1651       SET_DECL_OFFSET_ALIGN (expr, off_align);
1652     }
1653
1654   if (TREE_CODE (expr) == RESULT_DECL
1655       || TREE_CODE (expr) == PARM_DECL
1656       || TREE_CODE (expr) == VAR_DECL)
1657     {
1658       DECL_BY_REFERENCE (expr) = (unsigned) bp_unpack_value (bp, 1);
1659       if (TREE_CODE (expr) == VAR_DECL
1660           || TREE_CODE (expr) == PARM_DECL)
1661         DECL_HAS_VALUE_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1662       DECL_RESTRICTED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1663     }
1664 }
1665
1666
1667 /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
1668    of expression EXPR from bitpack BP.  */
1669
1670 static void
1671 unpack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
1672 {
1673   DECL_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1674 }
1675
1676
1677 /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
1678    of expression EXPR from bitpack BP.  */
1679
1680 static void
1681 unpack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
1682 {
1683   DECL_DEFER_OUTPUT (expr) = (unsigned) bp_unpack_value (bp, 1);
1684   DECL_COMMON (expr) = (unsigned) bp_unpack_value (bp, 1);
1685   DECL_DLLIMPORT_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1686   DECL_WEAK (expr) = (unsigned) bp_unpack_value (bp, 1);
1687   DECL_SEEN_IN_BIND_EXPR_P (expr) = (unsigned) bp_unpack_value (bp,  1);
1688   DECL_COMDAT (expr) = (unsigned) bp_unpack_value (bp,  1);
1689   DECL_VISIBILITY (expr) = (enum symbol_visibility) bp_unpack_value (bp,  2);
1690   DECL_VISIBILITY_SPECIFIED (expr) = (unsigned) bp_unpack_value (bp,  1);
1691
1692   if (TREE_CODE (expr) == VAR_DECL)
1693     {
1694       DECL_HARD_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1695       DECL_IN_TEXT_SECTION (expr) = (unsigned) bp_unpack_value (bp, 1);
1696       DECL_IN_CONSTANT_POOL (expr) = (unsigned) bp_unpack_value (bp, 1);
1697       DECL_TLS_MODEL (expr) = (enum tls_model) bp_unpack_value (bp,  3);
1698     }
1699
1700   if (VAR_OR_FUNCTION_DECL_P (expr))
1701     {
1702       priority_type p;
1703       p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1704       SET_DECL_INIT_PRIORITY (expr, p);
1705     }
1706 }
1707
1708
1709 /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
1710    of expression EXPR from bitpack BP.  */
1711
1712 static void
1713 unpack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
1714 {
1715   DECL_FUNCTION_CODE (expr) = (enum built_in_function) bp_unpack_value (bp, 11);
1716   DECL_BUILT_IN_CLASS (expr) = (enum built_in_class) bp_unpack_value (bp, 2);
1717   DECL_STATIC_CONSTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1718   DECL_STATIC_DESTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1719   DECL_UNINLINABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1720   DECL_POSSIBLY_INLINED (expr) = (unsigned) bp_unpack_value (bp, 1);
1721   DECL_IS_NOVOPS (expr) = (unsigned) bp_unpack_value (bp, 1);
1722   DECL_IS_RETURNS_TWICE (expr) = (unsigned) bp_unpack_value (bp, 1);
1723   DECL_IS_MALLOC (expr) = (unsigned) bp_unpack_value (bp, 1);
1724   DECL_IS_OPERATOR_NEW (expr) = (unsigned) bp_unpack_value (bp, 1);
1725   DECL_DECLARED_INLINE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1726   DECL_STATIC_CHAIN (expr) = (unsigned) bp_unpack_value (bp, 1);
1727   DECL_NO_INLINE_WARNING_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1728   DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr)
1729                         = (unsigned) bp_unpack_value (bp, 1);
1730   DECL_NO_LIMIT_STACK (expr) = (unsigned) bp_unpack_value (bp, 1);
1731   DECL_DISREGARD_INLINE_LIMITS (expr) = (unsigned) bp_unpack_value (bp, 1);
1732   DECL_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1733   DECL_LOOPING_CONST_OR_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1734   if (DECL_STATIC_DESTRUCTOR (expr))
1735     {
1736        priority_type p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1737        SET_DECL_FINI_PRIORITY (expr, p);
1738     }
1739 }
1740
1741
1742 /* Unpack all the non-pointer fields of the TS_TYPE structure
1743    of expression EXPR from bitpack BP.  */
1744
1745 static void
1746 unpack_ts_type_value_fields (struct bitpack_d *bp, tree expr)
1747 {
1748   enum machine_mode mode;
1749
1750   TYPE_PRECISION (expr) = (unsigned) bp_unpack_value (bp, 10);
1751   mode = (enum machine_mode) bp_unpack_value (bp, 8);
1752   SET_TYPE_MODE (expr, mode);
1753   TYPE_STRING_FLAG (expr) = (unsigned) bp_unpack_value (bp, 1);
1754   TYPE_NO_FORCE_BLK (expr) = (unsigned) bp_unpack_value (bp, 1);
1755   TYPE_NEEDS_CONSTRUCTING (expr) = (unsigned) bp_unpack_value (bp, 1);
1756   if (RECORD_OR_UNION_TYPE_P (expr))
1757     TYPE_TRANSPARENT_AGGR (expr) = (unsigned) bp_unpack_value (bp, 1);
1758   TYPE_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1759   TYPE_RESTRICT (expr) = (unsigned) bp_unpack_value (bp, 1);
1760   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
1761         = (unsigned) bp_unpack_value (bp, 2);
1762   TYPE_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1763   TYPE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1764   TYPE_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1765   TYPE_ALIAS_SET (expr) = bp_unpack_value (bp, HOST_BITS_PER_INT);
1766 }
1767
1768
1769 /* Unpack all the non-pointer fields of the TS_BLOCK structure
1770    of expression EXPR from bitpack BP.  */
1771
1772 static void
1773 unpack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
1774 {
1775   BLOCK_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1776   BLOCK_NUMBER (expr) = (unsigned) bp_unpack_value (bp, 31);
1777 }
1778
1779 /* Unpack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL
1780    structure of expression EXPR from bitpack BP.  */
1781
1782 static void
1783 unpack_ts_translation_unit_decl_value_fields (struct bitpack_d *bp ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
1784 {
1785 }
1786
1787 /* Unpack all the non-pointer fields in EXPR into a bit pack.  */
1788
1789 static void
1790 unpack_value_fields (struct bitpack_d *bp, tree expr)
1791 {
1792   enum tree_code code;
1793
1794   code = TREE_CODE (expr);
1795
1796   /* Note that all these functions are highly sensitive to changes in
1797      the types and sizes of each of the fields being packed.  */
1798   unpack_ts_base_value_fields (bp, expr);
1799
1800   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
1801     unpack_ts_real_cst_value_fields (bp, expr);
1802
1803   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
1804     unpack_ts_fixed_cst_value_fields (bp, expr);
1805
1806   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1807     unpack_ts_decl_common_value_fields (bp, expr);
1808
1809   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
1810     unpack_ts_decl_wrtl_value_fields (bp, expr);
1811
1812   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1813     unpack_ts_decl_with_vis_value_fields (bp, expr);
1814
1815   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1816     unpack_ts_function_decl_value_fields (bp, expr);
1817
1818   if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
1819     unpack_ts_type_value_fields (bp, expr);
1820
1821   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1822     unpack_ts_block_value_fields (bp, expr);
1823
1824   if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
1825     {
1826       /* We only stream the version number of SSA names.  */
1827       gcc_unreachable ();
1828     }
1829
1830   if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
1831     {
1832       /* This is only used by GENERIC.  */
1833       gcc_unreachable ();
1834     }
1835
1836   if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
1837     {
1838       /* This is only used by High GIMPLE.  */
1839       gcc_unreachable ();
1840     }
1841
1842   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
1843     unpack_ts_translation_unit_decl_value_fields (bp, expr);
1844 }
1845
1846
1847 /* Materialize a new tree from input block IB using descriptors in
1848    DATA_IN.  The code for the new tree should match TAG.  Store in
1849    *IX_P the index into the reader cache where the new tree is stored.  */
1850
1851 static tree
1852 lto_materialize_tree (struct lto_input_block *ib, struct data_in *data_in,
1853                       enum LTO_tags tag)
1854 {
1855   struct bitpack_d bp;
1856   enum tree_code code;
1857   tree result;
1858 #ifdef LTO_STREAMER_DEBUG
1859   HOST_WIDEST_INT orig_address_in_writer;
1860 #endif
1861
1862   result = NULL_TREE;
1863
1864 #ifdef LTO_STREAMER_DEBUG
1865   /* Read the word representing the memory address for the tree
1866      as it was written by the writer.  This is useful when
1867      debugging differences between the writer and reader.  */
1868   orig_address_in_writer = lto_input_sleb128 (ib);
1869   gcc_assert ((intptr_t) orig_address_in_writer == orig_address_in_writer);
1870 #endif
1871
1872   code = lto_tag_to_tree_code (tag);
1873
1874   /* We should never see an SSA_NAME tree.  Only the version numbers of
1875      SSA names are ever written out.  See input_ssa_names.  */
1876   gcc_assert (code != SSA_NAME);
1877
1878   /* Instantiate a new tree using the header data.  */
1879   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1880     result = input_string_cst (data_in, ib);
1881   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1882     result = input_identifier (data_in, ib);
1883   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1884     {
1885       HOST_WIDE_INT len = lto_input_sleb128 (ib);
1886       result = make_tree_vec (len);
1887     }
1888   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1889     {
1890       unsigned HOST_WIDE_INT len = lto_input_uleb128 (ib);
1891       result = make_tree_binfo (len);
1892     }
1893   else
1894     {
1895       /* All other nodes can be materialized with a raw make_node call.  */
1896       result = make_node (code);
1897     }
1898
1899 #ifdef LTO_STREAMER_DEBUG
1900   /* Store the original address of the tree as seen by the writer
1901      in RESULT's aux field.  This is useful when debugging streaming
1902      problems.  This way, a debugging session can be started on
1903      both writer and reader with a breakpoint using this address
1904      value in both.  */
1905   lto_orig_address_map (result, (intptr_t) orig_address_in_writer);
1906 #endif
1907
1908   /* Read the bitpack of non-pointer values from IB.  */
1909   bp = lto_input_bitpack (ib);
1910
1911   /* The first word in BP contains the code of the tree that we
1912      are about to read.  */
1913   code = (enum tree_code) bp_unpack_value (&bp, 16);
1914   lto_tag_check (lto_tree_code_to_tag (code), tag);
1915
1916   /* Unpack all the value fields from BP.  */
1917   unpack_value_fields (&bp, result);
1918
1919   /* Enter RESULT in the reader cache.  This will make RESULT
1920      available so that circular references in the rest of the tree
1921      structure can be resolved in subsequent calls to lto_input_tree.  */
1922   lto_streamer_cache_append (data_in->reader_cache, result);
1923
1924   return result;
1925 }
1926
1927
1928 /* Read all pointer fields in the TS_COMMON structure of EXPR from input
1929    block IB.  DATA_IN contains tables and descriptors for the
1930    file being read.  */
1931
1932
1933 static void
1934 lto_input_ts_common_tree_pointers (struct lto_input_block *ib,
1935                                    struct data_in *data_in, tree expr)
1936 {
1937   if (TREE_CODE (expr) != IDENTIFIER_NODE)
1938     TREE_TYPE (expr) = lto_input_tree (ib, data_in);
1939 }
1940
1941
1942 /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
1943    block IB.  DATA_IN contains tables and descriptors for the
1944    file being read.  */
1945
1946 static void
1947 lto_input_ts_vector_tree_pointers (struct lto_input_block *ib,
1948                                    struct data_in *data_in, tree expr)
1949 {
1950   TREE_VECTOR_CST_ELTS (expr) = lto_input_chain (ib, data_in);
1951 }
1952
1953
1954 /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
1955    block IB.  DATA_IN contains tables and descriptors for the
1956    file being read.  */
1957
1958 static void
1959 lto_input_ts_complex_tree_pointers (struct lto_input_block *ib,
1960                                     struct data_in *data_in, tree expr)
1961 {
1962   TREE_REALPART (expr) = lto_input_tree (ib, data_in);
1963   TREE_IMAGPART (expr) = lto_input_tree (ib, data_in);
1964 }
1965
1966
1967 /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
1968    from input block IB.  DATA_IN contains tables and descriptors for the
1969    file being read.  */
1970
1971 static void
1972 lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block *ib,
1973                                          struct data_in *data_in, tree expr)
1974 {
1975   DECL_NAME (expr) = lto_input_tree (ib, data_in);
1976   DECL_CONTEXT (expr) = lto_input_tree (ib, data_in);
1977   DECL_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
1978 }
1979
1980
1981 /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
1982    input block IB.  DATA_IN contains tables and descriptors for the
1983    file being read.  */
1984
1985 static void
1986 lto_input_ts_decl_common_tree_pointers (struct lto_input_block *ib,
1987                                         struct data_in *data_in, tree expr)
1988 {
1989   DECL_SIZE (expr) = lto_input_tree (ib, data_in);
1990   DECL_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
1991
1992   if (TREE_CODE (expr) != FUNCTION_DECL
1993       && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
1994     DECL_INITIAL (expr) = lto_input_tree (ib, data_in);
1995
1996   DECL_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
1997   /* Do not stream DECL_ABSTRACT_ORIGIN.  We cannot handle debug information
1998      for early inlining so drop it on the floor instead of ICEing in
1999      dwarf2out.c.  */
2000
2001   if (TREE_CODE (expr) == PARM_DECL)
2002     TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2003
2004   if ((TREE_CODE (expr) == VAR_DECL
2005        || TREE_CODE (expr) == PARM_DECL)
2006       && DECL_HAS_VALUE_EXPR_P (expr))
2007     SET_DECL_VALUE_EXPR (expr, lto_input_tree (ib, data_in));
2008
2009   if (TREE_CODE (expr) == VAR_DECL)
2010     {
2011       tree dexpr = lto_input_tree (ib, data_in);
2012       if (dexpr)
2013         SET_DECL_DEBUG_EXPR (expr, dexpr);
2014     }
2015 }
2016
2017
2018 /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
2019    EXPR from input block IB.  DATA_IN contains tables and descriptors for the
2020    file being read.  */
2021
2022 static void
2023 lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block *ib,
2024                                             struct data_in *data_in, tree expr)
2025 {
2026   if (TREE_CODE (expr) == FUNCTION_DECL)
2027     {
2028       DECL_ARGUMENTS (expr) = lto_input_tree (ib, data_in);
2029       DECL_RESULT (expr) = lto_input_tree (ib, data_in);
2030     }
2031   DECL_VINDEX (expr) = lto_input_tree (ib, data_in);
2032 }
2033
2034
2035 /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
2036    from input block IB.  DATA_IN contains tables and descriptors for the
2037    file being read.  */
2038
2039 static void
2040 lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block *ib,
2041                                           struct data_in *data_in, tree expr)
2042 {
2043   tree id;
2044
2045   id = lto_input_tree (ib, data_in);
2046   if (id)
2047     {
2048       gcc_assert (TREE_CODE (id) == IDENTIFIER_NODE);
2049       SET_DECL_ASSEMBLER_NAME (expr, id);
2050     }
2051
2052   DECL_SECTION_NAME (expr) = lto_input_tree (ib, data_in);
2053   DECL_COMDAT_GROUP (expr) = lto_input_tree (ib, data_in);
2054 }
2055
2056
2057 /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
2058    input block IB.  DATA_IN contains tables and descriptors for the
2059    file being read.  */
2060
2061 static void
2062 lto_input_ts_field_decl_tree_pointers (struct lto_input_block *ib,
2063                                        struct data_in *data_in, tree expr)
2064 {
2065   DECL_FIELD_OFFSET (expr) = lto_input_tree (ib, data_in);
2066   DECL_BIT_FIELD_TYPE (expr) = lto_input_tree (ib, data_in);
2067   DECL_QUALIFIER (expr) = lto_input_tree (ib, data_in);
2068   DECL_FIELD_BIT_OFFSET (expr) = lto_input_tree (ib, data_in);
2069   DECL_FCONTEXT (expr) = lto_input_tree (ib, data_in);
2070   TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2071 }
2072
2073
2074 /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
2075    from input block IB.  DATA_IN contains tables and descriptors for the
2076    file being read.  */
2077
2078 static void
2079 lto_input_ts_function_decl_tree_pointers (struct lto_input_block *ib,
2080                                           struct data_in *data_in, tree expr)
2081 {
2082   /* DECL_STRUCT_FUNCTION is handled by lto_input_function.  FIXME lto,
2083      maybe it should be handled here?  */
2084   DECL_FUNCTION_PERSONALITY (expr) = lto_input_tree (ib, data_in);
2085   DECL_FUNCTION_SPECIFIC_TARGET (expr) = lto_input_tree (ib, data_in);
2086   DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = lto_input_tree (ib, data_in);
2087
2088   /* If the file contains a function with an EH personality set,
2089      then it was compiled with -fexceptions.  In that case, initialize
2090      the backend EH machinery.  */
2091   if (DECL_FUNCTION_PERSONALITY (expr))
2092     lto_init_eh ();
2093 }
2094
2095
2096 /* Read all pointer fields in the TS_TYPE structure of EXPR from input
2097    block IB.  DATA_IN contains tables and descriptors for the
2098    file being read.  */
2099
2100 static void
2101 lto_input_ts_type_tree_pointers (struct lto_input_block *ib,
2102                                  struct data_in *data_in, tree expr)
2103 {
2104   if (TREE_CODE (expr) == ENUMERAL_TYPE)
2105     TYPE_VALUES (expr) = lto_input_tree (ib, data_in);
2106   else if (TREE_CODE (expr) == ARRAY_TYPE)
2107     TYPE_DOMAIN (expr) = lto_input_tree (ib, data_in);
2108   else if (RECORD_OR_UNION_TYPE_P (expr))
2109     TYPE_FIELDS (expr) = lto_input_tree (ib, data_in);
2110   else if (TREE_CODE (expr) == FUNCTION_TYPE
2111            || TREE_CODE (expr) == METHOD_TYPE)
2112     TYPE_ARG_TYPES (expr) = lto_input_tree (ib, data_in);
2113
2114   TYPE_SIZE (expr) = lto_input_tree (ib, data_in);
2115   TYPE_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
2116   TYPE_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
2117   TYPE_NAME (expr) = lto_input_tree (ib, data_in);
2118   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
2119      TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO.  */
2120   if (!POINTER_TYPE_P (expr))
2121     TYPE_MINVAL (expr) = lto_input_tree (ib, data_in);
2122   TYPE_MAXVAL (expr) = lto_input_tree (ib, data_in);
2123   TYPE_MAIN_VARIANT (expr) = lto_input_tree (ib, data_in);
2124   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
2125      during fixup.  */
2126   if (RECORD_OR_UNION_TYPE_P (expr))
2127     TYPE_BINFO (expr) = lto_input_tree (ib, data_in);
2128   TYPE_CONTEXT (expr) = lto_input_tree (ib, data_in);
2129   /* TYPE_CANONICAL gets re-computed during type merging.  */
2130   TYPE_CANONICAL (expr) = NULL_TREE;
2131   TYPE_STUB_DECL (expr) = lto_input_tree (ib, data_in);
2132 }
2133
2134
2135 /* Read all pointer fields in the TS_LIST structure of EXPR from input
2136    block IB.  DATA_IN contains tables and descriptors for the
2137    file being read.  */
2138
2139 static void
2140 lto_input_ts_list_tree_pointers (struct lto_input_block *ib,
2141                                  struct data_in *data_in, tree expr)
2142 {
2143   TREE_PURPOSE (expr) = lto_input_tree (ib, data_in);
2144   TREE_VALUE (expr) = lto_input_tree (ib, data_in);
2145   TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2146 }
2147
2148
2149 /* Read all pointer fields in the TS_VEC structure of EXPR from input
2150    block IB.  DATA_IN contains tables and descriptors for the
2151    file being read.  */
2152
2153 static void
2154 lto_input_ts_vec_tree_pointers (struct lto_input_block *ib,
2155                                 struct data_in *data_in, tree expr)
2156 {
2157   int i;
2158
2159   /* Note that TREE_VEC_LENGTH was read by lto_materialize_tree to
2160      instantiate EXPR.  */
2161   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
2162     TREE_VEC_ELT (expr, i) = lto_input_tree (ib, data_in);
2163 }
2164
2165
2166 /* Read all pointer fields in the TS_EXP structure of EXPR from input
2167    block IB.  DATA_IN contains tables and descriptors for the
2168    file being read.  */
2169
2170
2171 static void
2172 lto_input_ts_exp_tree_pointers (struct lto_input_block *ib,
2173                                 struct data_in *data_in, tree expr)
2174 {
2175   int i, length;
2176   location_t loc;
2177
2178   length = lto_input_sleb128 (ib);
2179   gcc_assert (length == TREE_OPERAND_LENGTH (expr));
2180
2181   for (i = 0; i < length; i++)
2182     TREE_OPERAND (expr, i) = lto_input_tree (ib, data_in);
2183
2184   loc = lto_input_location (ib, data_in);
2185   SET_EXPR_LOCATION (expr, loc);
2186   TREE_BLOCK (expr) = lto_input_tree (ib, data_in);
2187 }
2188
2189
2190 /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
2191    block IB.  DATA_IN contains tables and descriptors for the
2192    file being read.  */
2193
2194 static void
2195 lto_input_ts_block_tree_pointers (struct lto_input_block *ib,
2196                                   struct data_in *data_in, tree expr)
2197 {
2198   /* Do not stream BLOCK_SOURCE_LOCATION.  We cannot handle debug information
2199      for early inlining so drop it on the floor instead of ICEing in
2200      dwarf2out.c.  */
2201   BLOCK_VARS (expr) = lto_input_chain (ib, data_in);
2202
2203   /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information
2204      for early inlining so drop it on the floor instead of ICEing in
2205      dwarf2out.c.  */
2206
2207   BLOCK_SUPERCONTEXT (expr) = lto_input_tree (ib, data_in);
2208   /* Do not stream BLOCK_ABSTRACT_ORIGIN.  We cannot handle debug information
2209      for early inlining so drop it on the floor instead of ICEing in
2210      dwarf2out.c.  */
2211   BLOCK_FRAGMENT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2212   BLOCK_FRAGMENT_CHAIN (expr) = lto_input_tree (ib, data_in);
2213   /* We re-compute BLOCK_SUBBLOCKS of our parent here instead
2214      of streaming it.  For non-BLOCK BLOCK_SUPERCONTEXTs we still
2215      stream the child relationship explicitly.  */
2216   if (BLOCK_SUPERCONTEXT (expr)
2217       && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == BLOCK)
2218     {
2219       BLOCK_CHAIN (expr) = BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr));
2220       BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr)) = expr;
2221     }
2222   /* The global block is rooted at the TU decl.  Hook it here to
2223      avoid the need to stream in this block during WPA time.  */
2224   else if (BLOCK_SUPERCONTEXT (expr)
2225            && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == TRANSLATION_UNIT_DECL)
2226     DECL_INITIAL (BLOCK_SUPERCONTEXT (expr)) = expr;
2227   /* The function-level block is connected at the time we read in
2228      function bodies for the same reason.  */
2229 }
2230
2231
2232 /* Read all pointer fields in the TS_BINFO structure of EXPR from input
2233    block IB.  DATA_IN contains tables and descriptors for the
2234    file being read.  */
2235
2236 static void
2237 lto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,
2238                                   struct data_in *data_in, tree expr)
2239 {
2240   unsigned i, len;
2241   tree t;
2242
2243   /* Note that the number of slots in EXPR was read in
2244      lto_materialize_tree when instantiating EXPR.  However, the
2245      vector is empty so we cannot rely on VEC_length to know how many
2246      elements to read.  So, this list is emitted as a 0-terminated
2247      list on the writer side.  */
2248   do
2249     {
2250       t = lto_input_tree (ib, data_in);
2251       if (t)
2252         VEC_quick_push (tree, BINFO_BASE_BINFOS (expr), t);
2253     }
2254   while (t);
2255
2256   BINFO_OFFSET (expr) = lto_input_tree (ib, data_in);
2257   BINFO_VTABLE (expr) = lto_input_tree (ib, data_in);
2258   BINFO_VIRTUALS (expr) = lto_input_tree (ib, data_in);
2259   BINFO_VPTR_FIELD (expr) = lto_input_tree (ib, data_in);
2260
2261   len = lto_input_uleb128 (ib);
2262   if (len > 0)
2263     {
2264       VEC_reserve_exact (tree, gc, BINFO_BASE_ACCESSES (expr), len);
2265       for (i = 0; i < len; i++)
2266         {
2267           tree a = lto_input_tree (ib, data_in);
2268           VEC_quick_push (tree, BINFO_BASE_ACCESSES (expr), a);
2269         }
2270     }
2271
2272   BINFO_INHERITANCE_CHAIN (expr) = lto_input_tree (ib, data_in);
2273   BINFO_SUBVTT_INDEX (expr) = lto_input_tree (ib, data_in);
2274   BINFO_VPTR_INDEX (expr) = lto_input_tree (ib, data_in);
2275 }
2276
2277
2278 /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
2279    input block IB.  DATA_IN contains tables and descriptors for the
2280    file being read.  */
2281
2282 static void
2283 lto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,
2284                                         struct data_in *data_in, tree expr)
2285 {
2286   unsigned i, len;
2287
2288   len = lto_input_uleb128 (ib);
2289   for (i = 0; i < len; i++)
2290     {
2291       tree index, value;
2292
2293       index = lto_input_tree (ib, data_in);
2294       value = lto_input_tree (ib, data_in);
2295       CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr), index, value);
2296     }
2297 }
2298
2299
2300 /* Input a TS_TARGET_OPTION tree from IB into EXPR.  */
2301
2302 static void
2303 lto_input_ts_target_option (struct lto_input_block *ib, tree expr)
2304 {
2305   unsigned i, len;
2306   struct bitpack_d bp;
2307   struct cl_target_option *t = TREE_TARGET_OPTION (expr);
2308
2309   bp = lto_input_bitpack (ib);
2310   len = sizeof (struct cl_target_option);
2311   for (i = 0; i < len; i++)
2312     ((unsigned char *)t)[i] = bp_unpack_value (&bp, 8);
2313   if (bp_unpack_value (&bp, 32) != 0x12345678)
2314     fatal_error ("cl_target_option size mismatch in LTO reader and writer");
2315 }
2316
2317 /* Input a TS_TRANSLATION_UNIT_DECL tree from IB and DATA_IN into EXPR.  */
2318
2319 static void
2320 lto_input_ts_translation_unit_decl_tree_pointers (struct lto_input_block *ib,
2321                                                   struct data_in *data_in,
2322                                                   tree expr)
2323 {
2324   TRANSLATION_UNIT_LANGUAGE (expr) = xstrdup (lto_input_string (data_in, ib));
2325   VEC_safe_push (tree, gc, all_translation_units, expr);
2326 }
2327
2328 /* Helper for lto_input_tree.  Read all pointer fields in EXPR from
2329    input block IB.  DATA_IN contains tables and descriptors for the
2330    file being read.  */
2331
2332 static void
2333 lto_input_tree_pointers (struct lto_input_block *ib, struct data_in *data_in,
2334                          tree expr)
2335 {
2336   enum tree_code code;
2337
2338   code = TREE_CODE (expr);
2339
2340   if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
2341     lto_input_ts_common_tree_pointers (ib, data_in, expr);
2342
2343   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
2344     lto_input_ts_vector_tree_pointers (ib, data_in, expr);
2345
2346   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
2347     lto_input_ts_complex_tree_pointers (ib, data_in, expr);
2348
2349   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
2350     lto_input_ts_decl_minimal_tree_pointers (ib, data_in, expr);
2351
2352   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
2353     lto_input_ts_decl_common_tree_pointers (ib, data_in, expr);
2354
2355   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
2356     lto_input_ts_decl_non_common_tree_pointers (ib, data_in, expr);
2357
2358   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
2359     lto_input_ts_decl_with_vis_tree_pointers (ib, data_in, expr);
2360
2361   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
2362     lto_input_ts_field_decl_tree_pointers (ib, data_in, expr);
2363
2364   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
2365     lto_input_ts_function_decl_tree_pointers (ib, data_in, expr);
2366
2367   if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
2368     lto_input_ts_type_tree_pointers (ib, data_in, expr);
2369
2370   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
2371     lto_input_ts_list_tree_pointers (ib, data_in, expr);
2372
2373   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
2374     lto_input_ts_vec_tree_pointers (ib, data_in, expr);
2375
2376   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
2377     lto_input_ts_exp_tree_pointers (ib, data_in, expr);
2378
2379   if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
2380     {
2381       /* We only stream the version number of SSA names.  */
2382       gcc_unreachable ();
2383     }
2384
2385   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
2386     lto_input_ts_block_tree_pointers (ib, data_in, expr);
2387
2388   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
2389     lto_input_ts_binfo_tree_pointers (ib, data_in, expr);
2390
2391   if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
2392     {
2393       /* This should only appear in GENERIC.  */
2394       gcc_unreachable ();
2395     }
2396
2397   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
2398     lto_input_ts_constructor_tree_pointers (ib, data_in, expr);
2399
2400   if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
2401     {
2402       /* This should only appear in High GIMPLE.  */
2403       gcc_unreachable ();
2404     }
2405
2406   if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
2407     {
2408       sorry ("optimization options not supported yet");
2409     }
2410
2411   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
2412     lto_input_ts_target_option (ib, expr);
2413
2414   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
2415     lto_input_ts_translation_unit_decl_tree_pointers (ib, data_in, expr);
2416 }
2417
2418
2419 /* Register DECL with the global symbol table and change its
2420    name if necessary to avoid name clashes for static globals across
2421    different files.  */
2422
2423 static void
2424 lto_register_var_decl_in_symtab (struct data_in *data_in, tree decl)
2425 {
2426   tree context;
2427
2428   /* Variable has file scope, not local. Need to ensure static variables
2429      between different files don't clash unexpectedly.  */
2430   if (!TREE_PUBLIC (decl)
2431       && !((context = decl_function_context (decl))
2432            && auto_var_in_fn_p (decl, context)))
2433     {
2434       /* ??? We normally pre-mangle names before we serialize them
2435          out.  Here, in lto1, we do not know the language, and
2436          thus cannot do the mangling again. Instead, we just
2437          append a suffix to the mangled name.  The resulting name,
2438          however, is not a properly-formed mangled name, and will
2439          confuse any attempt to unmangle it.  */
2440       const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2441       char *label;
2442
2443       ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2444       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2445       rest_of_decl_compilation (decl, 1, 0);
2446
2447       VEC_safe_push (tree, gc, lto_global_var_decls, decl);
2448     }
2449
2450   /* If this variable has already been declared, queue the
2451      declaration for merging.  */
2452   if (TREE_PUBLIC (decl))
2453     {
2454       unsigned ix;
2455       if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2456         gcc_unreachable ();
2457       lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2458                                 data_in->file_data);
2459     }
2460 }
2461
2462
2463
2464 /* Register DECL with the global symbol table and change its
2465    name if necessary to avoid name clashes for static globals across
2466    different files.  DATA_IN contains descriptors and tables for the
2467    file being read.  */
2468
2469 static void
2470 lto_register_function_decl_in_symtab (struct data_in *data_in, tree decl)
2471 {
2472   /* Need to ensure static entities between different files
2473      don't clash unexpectedly.  */
2474   if (!TREE_PUBLIC (decl))
2475     {
2476       /* We must not use the DECL_ASSEMBLER_NAME macro here, as it
2477          may set the assembler name where it was previously empty.  */
2478       tree old_assembler_name = decl->decl_with_vis.assembler_name;
2479
2480       /* FIXME lto: We normally pre-mangle names before we serialize
2481          them out.  Here, in lto1, we do not know the language, and
2482          thus cannot do the mangling again. Instead, we just append a
2483          suffix to the mangled name.  The resulting name, however, is
2484          not a properly-formed mangled name, and will confuse any
2485          attempt to unmangle it.  */
2486       const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2487       char *label;
2488
2489       ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2490       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2491
2492       /* We may arrive here with the old assembler name not set
2493          if the function body is not needed, e.g., it has been
2494          inlined away and does not appear in the cgraph.  */
2495       if (old_assembler_name)
2496         {
2497           tree new_assembler_name = DECL_ASSEMBLER_NAME (decl);
2498
2499           /* Make the original assembler name available for later use.
2500              We may have used it to indicate the section within its
2501              object file where the function body may be found.
2502              FIXME lto: Find a better way to maintain the function decl
2503              to body section mapping so we don't need this hack.  */
2504           lto_record_renamed_decl (data_in->file_data,
2505                                    IDENTIFIER_POINTER (old_assembler_name),
2506                                    IDENTIFIER_POINTER (new_assembler_name));
2507
2508           /* Also register the reverse mapping so that we can find the
2509              new name given to an existing assembler name (used when
2510              restoring alias pairs in input_constructors_or_inits.  */
2511           lto_record_renamed_decl (data_in->file_data,
2512                                    IDENTIFIER_POINTER (new_assembler_name),
2513                                    IDENTIFIER_POINTER (old_assembler_name));
2514         }
2515     }
2516
2517   /* If this variable has already been declared, queue the
2518      declaration for merging.  */
2519   if (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl))
2520     {
2521       unsigned ix;
2522       if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2523         gcc_unreachable ();
2524       lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2525                                 data_in->file_data);
2526     }
2527 }
2528
2529
2530 /* Read an index IX from input block IB and return the tree node at
2531    DATA_IN->FILE_DATA->GLOBALS_INDEX[IX].  */
2532
2533 static tree
2534 lto_get_pickled_tree (struct lto_input_block *ib, struct data_in *data_in)
2535 {
2536   unsigned HOST_WIDE_INT ix;
2537   tree result;
2538   enum LTO_tags expected_tag;
2539
2540   ix = lto_input_uleb128 (ib);
2541   expected_tag = (enum LTO_tags) lto_input_uleb128 (ib);
2542
2543   result = lto_streamer_cache_get (data_in->reader_cache, ix);
2544   gcc_assert (result
2545               && TREE_CODE (result) == lto_tag_to_tree_code (expected_tag));
2546
2547   return result;
2548 }
2549
2550
2551 /* Read a code and class from input block IB and return the
2552    corresponding builtin.  DATA_IN is as in lto_input_tree.  */
2553
2554 static tree
2555 lto_get_builtin_tree (struct lto_input_block *ib, struct data_in *data_in)
2556 {
2557   enum built_in_class fclass;
2558   enum built_in_function fcode;
2559   const char *asmname;
2560   tree result;
2561
2562   fclass = (enum built_in_class) lto_input_uleb128 (ib);
2563   gcc_assert (fclass == BUILT_IN_NORMAL || fclass == BUILT_IN_MD);
2564
2565   fcode = (enum built_in_function) lto_input_uleb128 (ib);
2566
2567   if (fclass == BUILT_IN_NORMAL)
2568     {
2569       gcc_assert (fcode < END_BUILTINS);
2570       result = built_in_decls[fcode];
2571       gcc_assert (result);
2572     }
2573   else if (fclass == BUILT_IN_MD)
2574     {
2575       result = targetm.builtin_decl (fcode, true);
2576       if (!result || result == error_mark_node)
2577         fatal_error ("target specific builtin not available");
2578     }
2579   else
2580     gcc_unreachable ();
2581
2582   asmname = lto_input_string (data_in, ib);
2583   if (asmname)
2584     set_builtin_user_assembler_name (result, asmname);
2585
2586   lto_streamer_cache_append (data_in->reader_cache, result);
2587
2588   return result;
2589 }
2590
2591
2592 /* Read the physical representation of a tree node with tag TAG from
2593    input block IB using the per-file context in DATA_IN.  */
2594
2595 static tree
2596 lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
2597                enum LTO_tags tag)
2598 {
2599   tree result;
2600
2601   result = lto_materialize_tree (ib, data_in, tag);
2602
2603   /* Read all the pointer fields in RESULT.  */
2604   lto_input_tree_pointers (ib, data_in, result);
2605
2606   /* We should never try to instantiate an MD or NORMAL builtin here.  */
2607   if (TREE_CODE (result) == FUNCTION_DECL)
2608     gcc_assert (!lto_stream_as_builtin_p (result));
2609
2610   if (TREE_CODE (result) == VAR_DECL)
2611     lto_register_var_decl_in_symtab (data_in, result);
2612   else if (TREE_CODE (result) == FUNCTION_DECL && !DECL_BUILT_IN (result))
2613     lto_register_function_decl_in_symtab (data_in, result);
2614
2615   /* end_marker = */ lto_input_1_unsigned (ib);
2616
2617 #ifdef LTO_STREAMER_DEBUG
2618   /* Remove the mapping to RESULT's original address set by
2619      lto_materialize_tree.  */
2620   lto_orig_address_remove (result);
2621 #endif
2622
2623   return result;
2624 }
2625
2626
2627 /* Read and INTEGER_CST node from input block IB using the per-file
2628    context in DATA_IN.  */
2629
2630 static tree
2631 lto_input_integer_cst (struct lto_input_block *ib, struct data_in *data_in)
2632 {
2633   tree result, type;
2634   HOST_WIDE_INT low, high;
2635   bool overflow_p;
2636
2637   type = lto_input_tree (ib, data_in);
2638   overflow_p = (lto_input_1_unsigned (ib) != 0);
2639   low = lto_input_uleb128 (ib);
2640   high = lto_input_uleb128 (ib);
2641   result = build_int_cst_wide (type, low, high);
2642
2643   /* If the original constant had overflown, build a replica of RESULT to
2644      avoid modifying the shared constant returned by build_int_cst_wide.  */
2645   if (overflow_p)
2646     {
2647       result = copy_node (result);
2648       TREE_OVERFLOW (result) = 1;
2649     }
2650
2651   return result;
2652 }
2653
2654
2655 /* Read a tree from input block IB using the per-file context in
2656    DATA_IN.  This context is used, for example, to resolve references
2657    to previously read nodes.  */
2658
2659 tree
2660 lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
2661 {
2662   enum LTO_tags tag;
2663   tree result;
2664
2665   tag = input_record_start (ib);
2666   gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
2667
2668   if (tag == LTO_null)
2669     result = NULL_TREE;
2670   else if (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
2671     {
2672       /* If TAG is a reference to an indexable tree, the next value
2673          in IB is the index into the table where we expect to find
2674          that tree.  */
2675       result = lto_input_tree_ref (ib, data_in, cfun, tag);
2676     }
2677   else if (tag == LTO_tree_pickle_reference)
2678     {
2679       /* If TAG is a reference to a previously read tree, look it up in
2680          the reader cache.  */
2681       result = lto_get_pickled_tree (ib, data_in);
2682     }
2683   else if (tag == LTO_builtin_decl)
2684     {
2685       /* If we are going to read a built-in function, all we need is
2686          the code and class.  */
2687       result = lto_get_builtin_tree (ib, data_in);
2688     }
2689   else if (tag == lto_tree_code_to_tag (INTEGER_CST))
2690     {
2691       /* For integer constants we only need the type and its hi/low
2692          words.  */
2693       result = lto_input_integer_cst (ib, data_in);
2694     }
2695   else
2696     {
2697       /* Otherwise, materialize a new node from IB.  */
2698       result = lto_read_tree (ib, data_in, tag);
2699     }
2700
2701   return result;
2702 }
2703
2704
2705 /* Initialization for the LTO reader.  */
2706
2707 void
2708 lto_init_reader (void)
2709 {
2710   lto_streamer_init ();
2711
2712   memset (&lto_stats, 0, sizeof (lto_stats));
2713   bitmap_obstack_initialize (NULL);
2714
2715   file_name_hash_table = htab_create (37, hash_string_slot_node,
2716                                       eq_string_slot_node, free);
2717
2718   gimple_register_cfg_hooks ();
2719 }
2720
2721
2722 /* Create a new data_in object for FILE_DATA. STRINGS is the string
2723    table to use with LEN strings.  RESOLUTIONS is the vector of linker
2724    resolutions (NULL if not using a linker plugin).  */
2725
2726 struct data_in *
2727 lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
2728                     unsigned len,
2729                     VEC(ld_plugin_symbol_resolution_t,heap) *resolutions)
2730 {
2731   struct data_in *data_in = XCNEW (struct data_in);
2732   data_in->file_data = file_data;
2733   data_in->strings = strings;
2734   data_in->strings_len = len;
2735   data_in->globals_resolution = resolutions;
2736   data_in->reader_cache = lto_streamer_cache_create ();
2737
2738   return data_in;
2739 }
2740
2741
2742 /* Remove DATA_IN.  */
2743
2744 void
2745 lto_data_in_delete (struct data_in *data_in)
2746 {
2747   VEC_free (ld_plugin_symbol_resolution_t, heap, data_in->globals_resolution);
2748   lto_streamer_cache_delete (data_in->reader_cache);
2749   free (data_in->labels);
2750   free (data_in);
2751 }