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       if (is_gimple_call (stmt))
1066         {
1067           if (gimple_call_internal_p (stmt))
1068             gimple_call_set_internal_fn
1069               (stmt, (enum internal_fn) lto_input_sleb128 (ib));
1070           else
1071             gimple_call_set_fntype (stmt, lto_input_tree (ib, data_in));
1072         }
1073       break;
1074
1075     case GIMPLE_NOP:
1076     case GIMPLE_PREDICT:
1077       break;
1078
1079     default:
1080       internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
1081                       lto_tag_name (tag));
1082     }
1083
1084   /* Update the properties of symbols, SSA names and labels associated
1085      with STMT.  */
1086   if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
1087     {
1088       tree lhs = gimple_get_lhs (stmt);
1089       if (lhs && TREE_CODE (lhs) == SSA_NAME)
1090         SSA_NAME_DEF_STMT (lhs) = stmt;
1091     }
1092   else if (code == GIMPLE_LABEL)
1093     gcc_assert (emit_label_in_global_context_p (gimple_label_label (stmt))
1094                 || DECL_CONTEXT (gimple_label_label (stmt)) == fn->decl);
1095   else if (code == GIMPLE_ASM)
1096     {
1097       unsigned i;
1098
1099       for (i = 0; i < gimple_asm_noutputs (stmt); i++)
1100         {
1101           tree op = TREE_VALUE (gimple_asm_output_op (stmt, i));
1102           if (TREE_CODE (op) == SSA_NAME)
1103             SSA_NAME_DEF_STMT (op) = stmt;
1104         }
1105     }
1106
1107   /* Reset alias information.  */
1108   if (code == GIMPLE_CALL)
1109     gimple_call_reset_alias_info (stmt);
1110
1111   /* Mark the statement modified so its operand vectors can be filled in.  */
1112   gimple_set_modified (stmt, true);
1113
1114   return stmt;
1115 }
1116
1117
1118 /* Read a basic block with tag TAG from DATA_IN using input block IB.
1119    FN is the function being processed.  */
1120
1121 static void
1122 input_bb (struct lto_input_block *ib, enum LTO_tags tag,
1123           struct data_in *data_in, struct function *fn,
1124           int count_materialization_scale)
1125 {
1126   unsigned int index;
1127   basic_block bb;
1128   gimple_stmt_iterator bsi;
1129
1130   /* This routine assumes that CFUN is set to FN, as it needs to call
1131      basic GIMPLE routines that use CFUN.  */
1132   gcc_assert (cfun == fn);
1133
1134   index = lto_input_uleb128 (ib);
1135   bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
1136
1137   bb->count = (lto_input_sleb128 (ib) * count_materialization_scale
1138                + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE;
1139   bb->loop_depth = lto_input_sleb128 (ib);
1140   bb->frequency = lto_input_sleb128 (ib);
1141   bb->flags = lto_input_sleb128 (ib);
1142
1143   /* LTO_bb1 has statements.  LTO_bb0 does not.  */
1144   if (tag == LTO_bb0)
1145     return;
1146
1147   bsi = gsi_start_bb (bb);
1148   tag = input_record_start (ib);
1149   while (tag)
1150     {
1151       gimple stmt = input_gimple_stmt (ib, data_in, fn, tag);
1152       if (!is_gimple_debug (stmt))
1153         find_referenced_vars_in (stmt);
1154       gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1155
1156       /* After the statement, expect a 0 delimiter or the EH region
1157          that the previous statement belongs to.  */
1158       tag = input_record_start (ib);
1159       lto_tag_check_set (tag, 2, LTO_eh_region, LTO_null);
1160
1161       if (tag == LTO_eh_region)
1162         {
1163           HOST_WIDE_INT region = lto_input_sleb128 (ib);
1164           gcc_assert (region == (int) region);
1165           add_stmt_to_eh_lp (stmt, region);
1166         }
1167
1168       tag = input_record_start (ib);
1169     }
1170
1171   tag = input_record_start (ib);
1172   while (tag)
1173     {
1174       gimple phi = input_phi (ib, bb, data_in, fn);
1175       find_referenced_vars_in (phi);
1176       tag = input_record_start (ib);
1177     }
1178 }
1179
1180 /* Go through all NODE edges and fixup call_stmt pointers
1181    so they point to STMTS.  */
1182
1183 static void
1184 fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple *stmts)
1185 {
1186   struct cgraph_edge *cedge;
1187   for (cedge = node->callees; cedge; cedge = cedge->next_callee)
1188     cedge->call_stmt = stmts[cedge->lto_stmt_uid];
1189   for (cedge = node->indirect_calls; cedge; cedge = cedge->next_callee)
1190     cedge->call_stmt = stmts[cedge->lto_stmt_uid];
1191 }
1192
1193 /* Fixup call_stmt pointers in NODE and all clones.  */
1194
1195 static void
1196 fixup_call_stmt_edges (struct cgraph_node *orig, gimple *stmts)
1197 {
1198   struct cgraph_node *node;
1199
1200   while (orig->clone_of)
1201     orig = orig->clone_of;
1202
1203   fixup_call_stmt_edges_1 (orig, stmts);
1204   if (orig->clones)
1205     for (node = orig->clones; node != orig;)
1206       {
1207         fixup_call_stmt_edges_1 (node, stmts);
1208         if (node->clones)
1209           node = node->clones;
1210         else if (node->next_sibling_clone)
1211           node = node->next_sibling_clone;
1212         else
1213           {
1214             while (node != orig && !node->next_sibling_clone)
1215               node = node->clone_of;
1216             if (node != orig)
1217               node = node->next_sibling_clone;
1218           }
1219       }
1220 }
1221
1222 /* Read the body of function FN_DECL from DATA_IN using input block IB.  */
1223
1224 static void
1225 input_function (tree fn_decl, struct data_in *data_in,
1226                 struct lto_input_block *ib)
1227 {
1228   struct function *fn;
1229   enum LTO_tags tag;
1230   gimple *stmts;
1231   basic_block bb;
1232   struct bitpack_d bp;
1233   struct cgraph_node *node;
1234   tree args, narg, oarg;
1235   int len;
1236
1237   fn = DECL_STRUCT_FUNCTION (fn_decl);
1238   tag = input_record_start (ib);
1239   clear_line_info (data_in);
1240
1241   gimple_register_cfg_hooks ();
1242   lto_tag_check (tag, LTO_function);
1243
1244   /* Read all the attributes for FN.  */
1245   bp = lto_input_bitpack (ib);
1246   fn->is_thunk = bp_unpack_value (&bp, 1);
1247   fn->has_local_explicit_reg_vars = bp_unpack_value (&bp, 1);
1248   fn->after_tree_profile = bp_unpack_value (&bp, 1);
1249   fn->returns_pcc_struct = bp_unpack_value (&bp, 1);
1250   fn->returns_struct = bp_unpack_value (&bp, 1);
1251   fn->can_throw_non_call_exceptions = bp_unpack_value (&bp, 1);
1252   fn->always_inline_functions_inlined = bp_unpack_value (&bp, 1);
1253   fn->after_inlining = bp_unpack_value (&bp, 1);
1254   fn->dont_save_pending_sizes_p = bp_unpack_value (&bp, 1);
1255   fn->stdarg = bp_unpack_value (&bp, 1);
1256   fn->has_nonlocal_label = bp_unpack_value (&bp, 1);
1257   fn->calls_alloca = bp_unpack_value (&bp, 1);
1258   fn->calls_setjmp = bp_unpack_value (&bp, 1);
1259   fn->va_list_fpr_size = bp_unpack_value (&bp, 8);
1260   fn->va_list_gpr_size = bp_unpack_value (&bp, 8);
1261
1262   /* Input the function start and end loci.  */
1263   fn->function_start_locus = lto_input_location (ib, data_in);
1264   fn->function_end_locus = lto_input_location (ib, data_in);
1265
1266   /* Input the current IL state of the function.  */
1267   fn->curr_properties = lto_input_uleb128 (ib);
1268
1269   /* Read the static chain and non-local goto save area.  */
1270   fn->static_chain_decl = lto_input_tree (ib, data_in);
1271   fn->nonlocal_goto_save_area = lto_input_tree (ib, data_in);
1272
1273   /* Read all the local symbols.  */
1274   len = lto_input_sleb128 (ib);
1275   if (len > 0)
1276     {
1277       int i;
1278       VEC_safe_grow (tree, gc, fn->local_decls, len);
1279       for (i = 0; i < len; i++)
1280         {
1281           tree t = lto_input_tree (ib, data_in);
1282           VEC_replace (tree, fn->local_decls, i, t);
1283         }
1284     }
1285
1286   /* Read all function arguments.  We need to re-map them here to the
1287      arguments of the merged function declaration.  */
1288   args = lto_input_tree (ib, data_in);
1289   for (oarg = args, narg = DECL_ARGUMENTS (fn_decl);
1290        oarg && narg;
1291        oarg = TREE_CHAIN (oarg), narg = TREE_CHAIN (narg))
1292     {
1293       unsigned ix;
1294       bool res;
1295       res = lto_streamer_cache_lookup (data_in->reader_cache, oarg, &ix);
1296       gcc_assert (res);
1297       /* Replace the argument in the streamer cache.  */
1298       lto_streamer_cache_insert_at (data_in->reader_cache, narg, ix);
1299     }
1300   gcc_assert (!oarg && !narg);
1301
1302   /* Read all the SSA names.  */
1303   input_ssa_names (ib, data_in, fn);
1304
1305   /* Read the exception handling regions in the function.  */
1306   input_eh_regions (ib, data_in, fn);
1307
1308   /* Read the tree of lexical scopes for the function.  */
1309   DECL_INITIAL (fn_decl) = lto_input_tree (ib, data_in);
1310   gcc_assert (DECL_INITIAL (fn_decl));
1311   DECL_SAVED_TREE (fn_decl) = NULL_TREE;
1312   node = cgraph_get_create_node (fn_decl);
1313
1314   /* Read all the basic blocks.  */
1315   tag = input_record_start (ib);
1316   while (tag)
1317     {
1318       input_bb (ib, tag, data_in, fn,
1319                 node->count_materialization_scale);
1320       tag = input_record_start (ib);
1321     }
1322
1323   /* Fix up the call statements that are mentioned in the callgraph
1324      edges.  */
1325   set_gimple_stmt_max_uid (cfun, 0);
1326   FOR_ALL_BB (bb)
1327     {
1328       gimple_stmt_iterator gsi;
1329       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1330         {
1331           gimple stmt = gsi_stmt (gsi);
1332           gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
1333         }
1334     }
1335   stmts = (gimple *) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple));
1336   FOR_ALL_BB (bb)
1337     {
1338       gimple_stmt_iterator bsi = gsi_start_bb (bb);
1339       while (!gsi_end_p (bsi))
1340         {
1341           gimple stmt = gsi_stmt (bsi);
1342           /* If we're recompiling LTO objects with debug stmts but
1343              we're not supposed to have debug stmts, remove them now.
1344              We can't remove them earlier because this would cause uid
1345              mismatches in fixups, but we can do it at this point, as
1346              long as debug stmts don't require fixups.  */
1347           if (!MAY_HAVE_DEBUG_STMTS && is_gimple_debug (stmt))
1348             {
1349               gimple_stmt_iterator gsi = bsi;
1350               gsi_next (&bsi);
1351               gsi_remove (&gsi, true);
1352             }
1353           else
1354             {
1355               gsi_next (&bsi);
1356               stmts[gimple_uid (stmt)] = stmt;
1357             }
1358         }
1359     }
1360
1361   /* Set the gimple body to the statement sequence in the entry
1362      basic block.  FIXME lto, this is fairly hacky.  The existence
1363      of a gimple body is used by the cgraph routines, but we should
1364      really use the presence of the CFG.  */
1365   {
1366     edge_iterator ei = ei_start (ENTRY_BLOCK_PTR->succs);
1367     gimple_set_body (fn_decl, bb_seq (ei_edge (ei)->dest));
1368   }
1369
1370   fixup_call_stmt_edges (node, stmts);
1371   execute_all_ipa_stmt_fixups (node, stmts);
1372
1373   update_ssa (TODO_update_ssa_only_virtuals);
1374   free_dominance_info (CDI_DOMINATORS);
1375   free_dominance_info (CDI_POST_DOMINATORS);
1376   free (stmts);
1377 }
1378
1379
1380 /* Read initializer expressions for public statics.  DATA_IN is the
1381    file being read.  IB is the input block used for reading.  */
1382
1383 static void
1384 input_alias_pairs (struct lto_input_block *ib, struct data_in *data_in)
1385 {
1386   tree var;
1387
1388   clear_line_info (data_in);
1389
1390   var = lto_input_tree (ib, data_in);
1391   while (var)
1392     {
1393       const char *orig_name, *new_name;
1394       alias_pair *p;
1395
1396       p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
1397       p->decl = var;
1398       p->target = lto_input_tree (ib, data_in);
1399
1400       /* If the target is a static object, we may have registered a
1401          new name for it to avoid clashes between statics coming from
1402          different files.  In that case, use the new name.  */
1403       orig_name = IDENTIFIER_POINTER (p->target);
1404       new_name = lto_get_decl_name_mapping (data_in->file_data, orig_name);
1405       if (strcmp (orig_name, new_name) != 0)
1406         p->target = get_identifier (new_name);
1407
1408       var = lto_input_tree (ib, data_in);
1409     }
1410 }
1411
1412
1413 /* Read the body from DATA for function FN_DECL and fill it in.
1414    FILE_DATA are the global decls and types.  SECTION_TYPE is either
1415    LTO_section_function_body or LTO_section_static_initializer.  If
1416    section type is LTO_section_function_body, FN must be the decl for
1417    that function.  */
1418
1419 static void
1420 lto_read_body (struct lto_file_decl_data *file_data, tree fn_decl,
1421                const char *data, enum lto_section_type section_type)
1422 {
1423   const struct lto_function_header *header;
1424   struct data_in *data_in;
1425   int32_t cfg_offset;
1426   int32_t main_offset;
1427   int32_t string_offset;
1428   struct lto_input_block ib_cfg;
1429   struct lto_input_block ib_main;
1430
1431   header = (const struct lto_function_header *) data;
1432   cfg_offset = sizeof (struct lto_function_header);
1433   main_offset = cfg_offset + header->cfg_size;
1434   string_offset = main_offset + header->main_size;
1435
1436   LTO_INIT_INPUT_BLOCK (ib_cfg,
1437                         data + cfg_offset,
1438                         0,
1439                         header->cfg_size);
1440
1441   LTO_INIT_INPUT_BLOCK (ib_main,
1442                         data + main_offset,
1443                         0,
1444                         header->main_size);
1445
1446   data_in = lto_data_in_create (file_data, data + string_offset,
1447                                 header->string_size, NULL);
1448
1449   /* Make sure the file was generated by the exact same compiler.  */
1450   lto_check_version (header->lto_header.major_version,
1451                      header->lto_header.minor_version);
1452
1453   if (section_type == LTO_section_function_body)
1454     {
1455       struct function *fn = DECL_STRUCT_FUNCTION (fn_decl);
1456       struct lto_in_decl_state *decl_state;
1457       struct cgraph_node *node = cgraph_get_node (fn_decl);
1458
1459       gcc_checking_assert (node);
1460       push_cfun (fn);
1461       init_tree_ssa (fn);
1462
1463       /* Use the function's decl state. */
1464       decl_state = lto_get_function_in_decl_state (file_data, fn_decl);
1465       gcc_assert (decl_state);
1466       file_data->current_decl_state = decl_state;
1467
1468       input_cfg (&ib_cfg, fn, node->count_materialization_scale);
1469
1470       /* Set up the struct function.  */
1471       input_function (fn_decl, data_in, &ib_main);
1472
1473       /* We should now be in SSA.  */
1474       cfun->gimple_df->in_ssa_p = true;
1475
1476       /* Restore decl state */
1477       file_data->current_decl_state = file_data->global_decl_state;
1478
1479       pop_cfun ();
1480     }
1481   else
1482     {
1483       input_alias_pairs (&ib_main, data_in);
1484     }
1485
1486   clear_line_info (data_in);
1487   lto_data_in_delete (data_in);
1488 }
1489
1490
1491 /* Read the body of FN_DECL using DATA.  FILE_DATA holds the global
1492    decls and types.  */
1493
1494 void
1495 lto_input_function_body (struct lto_file_decl_data *file_data,
1496                          tree fn_decl, const char *data)
1497 {
1498   current_function_decl = fn_decl;
1499   lto_read_body (file_data, fn_decl, data, LTO_section_function_body);
1500 }
1501
1502
1503 /* Read in VAR_DECL using DATA.  FILE_DATA holds the global decls and
1504    types.  */
1505
1506 void
1507 lto_input_constructors_and_inits (struct lto_file_decl_data *file_data,
1508                                   const char *data)
1509 {
1510   lto_read_body (file_data, NULL, data, LTO_section_static_initializer);
1511 }
1512
1513
1514 /* Return the resolution for the decl with index INDEX from DATA_IN. */
1515
1516 static enum ld_plugin_symbol_resolution
1517 get_resolution (struct data_in *data_in, unsigned index)
1518 {
1519   if (data_in->globals_resolution)
1520     {
1521       ld_plugin_symbol_resolution_t ret;
1522       /* We can have references to not emitted functions in
1523          DECL_FUNCTION_PERSONALITY at least.  So we can and have
1524          to indeed return LDPR_UNKNOWN in some cases.   */
1525       if (VEC_length (ld_plugin_symbol_resolution_t,
1526                       data_in->globals_resolution) <= index)
1527         return LDPR_UNKNOWN;
1528       ret = VEC_index (ld_plugin_symbol_resolution_t,
1529                        data_in->globals_resolution,
1530                        index);
1531       return ret;
1532     }
1533   else
1534     /* Delay resolution finding until decl merging.  */
1535     return LDPR_UNKNOWN;
1536 }
1537
1538
1539 /* Unpack all the non-pointer fields of the TS_BASE structure of
1540    expression EXPR from bitpack BP.  */
1541
1542 static void
1543 unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
1544 {
1545   /* Note that the code for EXPR has already been unpacked to create EXPR in
1546      lto_materialize_tree.  */
1547   if (!TYPE_P (expr))
1548     {
1549       TREE_SIDE_EFFECTS (expr) = (unsigned) bp_unpack_value (bp, 1);
1550       TREE_CONSTANT (expr) = (unsigned) bp_unpack_value (bp, 1);
1551       TREE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1552
1553       /* TREE_PUBLIC is used on types to indicate that the type
1554          has a TYPE_CACHED_VALUES vector.  This is not streamed out,
1555          so we skip it here.  */
1556       TREE_PUBLIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1557     }
1558   else
1559     bp_unpack_value (bp, 4);
1560   TREE_ADDRESSABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1561   TREE_THIS_VOLATILE (expr) = (unsigned) bp_unpack_value (bp, 1);
1562   if (DECL_P (expr))
1563     DECL_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1564   else if (TYPE_P (expr))
1565     TYPE_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1566   else
1567     bp_unpack_value (bp, 1);
1568   TREE_ASM_WRITTEN (expr) = (unsigned) bp_unpack_value (bp, 1);
1569   TREE_NO_WARNING (expr) = (unsigned) bp_unpack_value (bp, 1);
1570   TREE_USED (expr) = (unsigned) bp_unpack_value (bp, 1);
1571   TREE_NOTHROW (expr) = (unsigned) bp_unpack_value (bp, 1);
1572   TREE_STATIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1573   TREE_PRIVATE (expr) = (unsigned) bp_unpack_value (bp, 1);
1574   TREE_PROTECTED (expr) = (unsigned) bp_unpack_value (bp, 1);
1575   TREE_DEPRECATED (expr) = (unsigned) bp_unpack_value (bp, 1);
1576   if (TYPE_P (expr))
1577     TYPE_SATURATING (expr) = (unsigned) bp_unpack_value (bp, 1);
1578   else if (TREE_CODE (expr) == SSA_NAME)
1579     SSA_NAME_IS_DEFAULT_DEF (expr) = (unsigned) bp_unpack_value (bp, 1);
1580   else
1581     bp_unpack_value (bp, 1);
1582 }
1583
1584
1585 /* Unpack all the non-pointer fields of the TS_REAL_CST structure of
1586    expression EXPR from bitpack BP.  */
1587
1588 static void
1589 unpack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
1590 {
1591   unsigned i;
1592   REAL_VALUE_TYPE r;
1593   REAL_VALUE_TYPE *rp;
1594
1595   r.cl = (unsigned) bp_unpack_value (bp, 2);
1596   r.decimal = (unsigned) bp_unpack_value (bp, 1);
1597   r.sign = (unsigned) bp_unpack_value (bp, 1);
1598   r.signalling = (unsigned) bp_unpack_value (bp, 1);
1599   r.canonical = (unsigned) bp_unpack_value (bp, 1);
1600   r.uexp = (unsigned) bp_unpack_value (bp, EXP_BITS);
1601   for (i = 0; i < SIGSZ; i++)
1602     r.sig[i] = (unsigned long) bp_unpack_value (bp, HOST_BITS_PER_LONG);
1603
1604   rp = ggc_alloc_real_value ();
1605   memcpy (rp, &r, sizeof (REAL_VALUE_TYPE));
1606   TREE_REAL_CST_PTR (expr) = rp;
1607 }
1608
1609
1610 /* Unpack all the non-pointer fields of the TS_FIXED_CST structure of
1611    expression EXPR from bitpack BP.  */
1612
1613 static void
1614 unpack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
1615 {
1616   struct fixed_value fv;
1617
1618   fv.data.low = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1619   fv.data.high = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1620   fv.mode = (enum machine_mode) bp_unpack_value (bp, HOST_BITS_PER_INT);
1621   TREE_FIXED_CST (expr) = fv;
1622 }
1623
1624
1625 /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure
1626    of expression EXPR from bitpack BP.  */
1627
1628 static void
1629 unpack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
1630 {
1631   DECL_MODE (expr) = (enum machine_mode) bp_unpack_value (bp, 8);
1632   DECL_NONLOCAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1633   DECL_VIRTUAL_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1634   DECL_IGNORED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1635   DECL_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1636   DECL_ARTIFICIAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1637   DECL_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1638   DECL_PRESERVE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1639   DECL_DEBUG_EXPR_IS_FROM (expr) = (unsigned) bp_unpack_value (bp, 1);
1640   DECL_EXTERNAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1641   DECL_GIMPLE_REG_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1642   DECL_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1643
1644   if (TREE_CODE (expr) == LABEL_DECL)
1645     {
1646       DECL_ERROR_ISSUED (expr) = (unsigned) bp_unpack_value (bp, 1);
1647       EH_LANDING_PAD_NR (expr) = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
1648
1649       /* Always assume an initial value of -1 for LABEL_DECL_UID to
1650          force gimple_set_bb to recreate label_to_block_map.  */
1651       LABEL_DECL_UID (expr) = -1;
1652     }
1653
1654   if (TREE_CODE (expr) == FIELD_DECL)
1655     {
1656       unsigned HOST_WIDE_INT off_align;
1657       DECL_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1658       DECL_NONADDRESSABLE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1659       off_align = (unsigned HOST_WIDE_INT) bp_unpack_value (bp, 8);
1660       SET_DECL_OFFSET_ALIGN (expr, off_align);
1661     }
1662
1663   if (TREE_CODE (expr) == RESULT_DECL
1664       || TREE_CODE (expr) == PARM_DECL
1665       || TREE_CODE (expr) == VAR_DECL)
1666     {
1667       DECL_BY_REFERENCE (expr) = (unsigned) bp_unpack_value (bp, 1);
1668       if (TREE_CODE (expr) == VAR_DECL
1669           || TREE_CODE (expr) == PARM_DECL)
1670         DECL_HAS_VALUE_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1671       DECL_RESTRICTED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1672     }
1673 }
1674
1675
1676 /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
1677    of expression EXPR from bitpack BP.  */
1678
1679 static void
1680 unpack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
1681 {
1682   DECL_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1683 }
1684
1685
1686 /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
1687    of expression EXPR from bitpack BP.  */
1688
1689 static void
1690 unpack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
1691 {
1692   DECL_DEFER_OUTPUT (expr) = (unsigned) bp_unpack_value (bp, 1);
1693   DECL_COMMON (expr) = (unsigned) bp_unpack_value (bp, 1);
1694   DECL_DLLIMPORT_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1695   DECL_WEAK (expr) = (unsigned) bp_unpack_value (bp, 1);
1696   DECL_SEEN_IN_BIND_EXPR_P (expr) = (unsigned) bp_unpack_value (bp,  1);
1697   DECL_COMDAT (expr) = (unsigned) bp_unpack_value (bp,  1);
1698   DECL_VISIBILITY (expr) = (enum symbol_visibility) bp_unpack_value (bp,  2);
1699   DECL_VISIBILITY_SPECIFIED (expr) = (unsigned) bp_unpack_value (bp,  1);
1700
1701   if (TREE_CODE (expr) == VAR_DECL)
1702     {
1703       DECL_HARD_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1704       DECL_IN_TEXT_SECTION (expr) = (unsigned) bp_unpack_value (bp, 1);
1705       DECL_IN_CONSTANT_POOL (expr) = (unsigned) bp_unpack_value (bp, 1);
1706       DECL_TLS_MODEL (expr) = (enum tls_model) bp_unpack_value (bp,  3);
1707     }
1708
1709   if (VAR_OR_FUNCTION_DECL_P (expr))
1710     {
1711       priority_type p;
1712       p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1713       SET_DECL_INIT_PRIORITY (expr, p);
1714     }
1715 }
1716
1717
1718 /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
1719    of expression EXPR from bitpack BP.  */
1720
1721 static void
1722 unpack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
1723 {
1724   DECL_FUNCTION_CODE (expr) = (enum built_in_function) bp_unpack_value (bp, 11);
1725   DECL_BUILT_IN_CLASS (expr) = (enum built_in_class) bp_unpack_value (bp, 2);
1726   DECL_STATIC_CONSTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1727   DECL_STATIC_DESTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1728   DECL_UNINLINABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1729   DECL_POSSIBLY_INLINED (expr) = (unsigned) bp_unpack_value (bp, 1);
1730   DECL_IS_NOVOPS (expr) = (unsigned) bp_unpack_value (bp, 1);
1731   DECL_IS_RETURNS_TWICE (expr) = (unsigned) bp_unpack_value (bp, 1);
1732   DECL_IS_MALLOC (expr) = (unsigned) bp_unpack_value (bp, 1);
1733   DECL_IS_OPERATOR_NEW (expr) = (unsigned) bp_unpack_value (bp, 1);
1734   DECL_DECLARED_INLINE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1735   DECL_STATIC_CHAIN (expr) = (unsigned) bp_unpack_value (bp, 1);
1736   DECL_NO_INLINE_WARNING_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1737   DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr)
1738                         = (unsigned) bp_unpack_value (bp, 1);
1739   DECL_NO_LIMIT_STACK (expr) = (unsigned) bp_unpack_value (bp, 1);
1740   DECL_DISREGARD_INLINE_LIMITS (expr) = (unsigned) bp_unpack_value (bp, 1);
1741   DECL_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1742   DECL_LOOPING_CONST_OR_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1743   if (DECL_STATIC_DESTRUCTOR (expr))
1744     {
1745        priority_type p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1746        SET_DECL_FINI_PRIORITY (expr, p);
1747     }
1748 }
1749
1750
1751 /* Unpack all the non-pointer fields of the TS_TYPE structure
1752    of expression EXPR from bitpack BP.  */
1753
1754 static void
1755 unpack_ts_type_value_fields (struct bitpack_d *bp, tree expr)
1756 {
1757   enum machine_mode mode;
1758
1759   TYPE_PRECISION (expr) = (unsigned) bp_unpack_value (bp, 10);
1760   mode = (enum machine_mode) bp_unpack_value (bp, 8);
1761   SET_TYPE_MODE (expr, mode);
1762   TYPE_STRING_FLAG (expr) = (unsigned) bp_unpack_value (bp, 1);
1763   TYPE_NO_FORCE_BLK (expr) = (unsigned) bp_unpack_value (bp, 1);
1764   TYPE_NEEDS_CONSTRUCTING (expr) = (unsigned) bp_unpack_value (bp, 1);
1765   if (RECORD_OR_UNION_TYPE_P (expr))
1766     TYPE_TRANSPARENT_AGGR (expr) = (unsigned) bp_unpack_value (bp, 1);
1767   TYPE_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1768   TYPE_RESTRICT (expr) = (unsigned) bp_unpack_value (bp, 1);
1769   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
1770         = (unsigned) bp_unpack_value (bp, 2);
1771   TYPE_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1772   TYPE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1773   TYPE_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1774   TYPE_ALIAS_SET (expr) = bp_unpack_value (bp, HOST_BITS_PER_INT);
1775 }
1776
1777
1778 /* Unpack all the non-pointer fields of the TS_BLOCK structure
1779    of expression EXPR from bitpack BP.  */
1780
1781 static void
1782 unpack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
1783 {
1784   BLOCK_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1785   BLOCK_NUMBER (expr) = (unsigned) bp_unpack_value (bp, 31);
1786 }
1787
1788 /* Unpack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL
1789    structure of expression EXPR from bitpack BP.  */
1790
1791 static void
1792 unpack_ts_translation_unit_decl_value_fields (struct bitpack_d *bp ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
1793 {
1794 }
1795
1796 /* Unpack all the non-pointer fields in EXPR into a bit pack.  */
1797
1798 static void
1799 unpack_value_fields (struct bitpack_d *bp, tree expr)
1800 {
1801   enum tree_code code;
1802
1803   code = TREE_CODE (expr);
1804
1805   /* Note that all these functions are highly sensitive to changes in
1806      the types and sizes of each of the fields being packed.  */
1807   unpack_ts_base_value_fields (bp, expr);
1808
1809   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
1810     unpack_ts_real_cst_value_fields (bp, expr);
1811
1812   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
1813     unpack_ts_fixed_cst_value_fields (bp, expr);
1814
1815   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1816     unpack_ts_decl_common_value_fields (bp, expr);
1817
1818   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
1819     unpack_ts_decl_wrtl_value_fields (bp, expr);
1820
1821   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1822     unpack_ts_decl_with_vis_value_fields (bp, expr);
1823
1824   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1825     unpack_ts_function_decl_value_fields (bp, expr);
1826
1827   if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
1828     unpack_ts_type_value_fields (bp, expr);
1829
1830   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1831     unpack_ts_block_value_fields (bp, expr);
1832
1833   if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
1834     {
1835       /* We only stream the version number of SSA names.  */
1836       gcc_unreachable ();
1837     }
1838
1839   if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
1840     {
1841       /* This is only used by GENERIC.  */
1842       gcc_unreachable ();
1843     }
1844
1845   if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
1846     {
1847       /* This is only used by High GIMPLE.  */
1848       gcc_unreachable ();
1849     }
1850
1851   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
1852     unpack_ts_translation_unit_decl_value_fields (bp, expr);
1853 }
1854
1855
1856 /* Materialize a new tree from input block IB using descriptors in
1857    DATA_IN.  The code for the new tree should match TAG.  Store in
1858    *IX_P the index into the reader cache where the new tree is stored.  */
1859
1860 static tree
1861 lto_materialize_tree (struct lto_input_block *ib, struct data_in *data_in,
1862                       enum LTO_tags tag)
1863 {
1864   struct bitpack_d bp;
1865   enum tree_code code;
1866   tree result;
1867 #ifdef LTO_STREAMER_DEBUG
1868   HOST_WIDEST_INT orig_address_in_writer;
1869 #endif
1870
1871   result = NULL_TREE;
1872
1873 #ifdef LTO_STREAMER_DEBUG
1874   /* Read the word representing the memory address for the tree
1875      as it was written by the writer.  This is useful when
1876      debugging differences between the writer and reader.  */
1877   orig_address_in_writer = lto_input_sleb128 (ib);
1878   gcc_assert ((intptr_t) orig_address_in_writer == orig_address_in_writer);
1879 #endif
1880
1881   code = lto_tag_to_tree_code (tag);
1882
1883   /* We should never see an SSA_NAME tree.  Only the version numbers of
1884      SSA names are ever written out.  See input_ssa_names.  */
1885   gcc_assert (code != SSA_NAME);
1886
1887   /* Instantiate a new tree using the header data.  */
1888   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1889     result = input_string_cst (data_in, ib);
1890   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1891     result = input_identifier (data_in, ib);
1892   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1893     {
1894       HOST_WIDE_INT len = lto_input_sleb128 (ib);
1895       result = make_tree_vec (len);
1896     }
1897   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1898     {
1899       unsigned HOST_WIDE_INT len = lto_input_uleb128 (ib);
1900       result = make_tree_binfo (len);
1901     }
1902   else
1903     {
1904       /* All other nodes can be materialized with a raw make_node call.  */
1905       result = make_node (code);
1906     }
1907
1908 #ifdef LTO_STREAMER_DEBUG
1909   /* Store the original address of the tree as seen by the writer
1910      in RESULT's aux field.  This is useful when debugging streaming
1911      problems.  This way, a debugging session can be started on
1912      both writer and reader with a breakpoint using this address
1913      value in both.  */
1914   lto_orig_address_map (result, (intptr_t) orig_address_in_writer);
1915 #endif
1916
1917   /* Read the bitpack of non-pointer values from IB.  */
1918   bp = lto_input_bitpack (ib);
1919
1920   /* The first word in BP contains the code of the tree that we
1921      are about to read.  */
1922   code = (enum tree_code) bp_unpack_value (&bp, 16);
1923   lto_tag_check (lto_tree_code_to_tag (code), tag);
1924
1925   /* Unpack all the value fields from BP.  */
1926   unpack_value_fields (&bp, result);
1927
1928   /* Enter RESULT in the reader cache.  This will make RESULT
1929      available so that circular references in the rest of the tree
1930      structure can be resolved in subsequent calls to lto_input_tree.  */
1931   lto_streamer_cache_append (data_in->reader_cache, result);
1932
1933   return result;
1934 }
1935
1936
1937 /* Read all pointer fields in the TS_COMMON structure of EXPR from input
1938    block IB.  DATA_IN contains tables and descriptors for the
1939    file being read.  */
1940
1941
1942 static void
1943 lto_input_ts_common_tree_pointers (struct lto_input_block *ib,
1944                                    struct data_in *data_in, tree expr)
1945 {
1946   if (TREE_CODE (expr) != IDENTIFIER_NODE)
1947     TREE_TYPE (expr) = lto_input_tree (ib, data_in);
1948 }
1949
1950
1951 /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
1952    block IB.  DATA_IN contains tables and descriptors for the
1953    file being read.  */
1954
1955 static void
1956 lto_input_ts_vector_tree_pointers (struct lto_input_block *ib,
1957                                    struct data_in *data_in, tree expr)
1958 {
1959   TREE_VECTOR_CST_ELTS (expr) = lto_input_chain (ib, data_in);
1960 }
1961
1962
1963 /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
1964    block IB.  DATA_IN contains tables and descriptors for the
1965    file being read.  */
1966
1967 static void
1968 lto_input_ts_complex_tree_pointers (struct lto_input_block *ib,
1969                                     struct data_in *data_in, tree expr)
1970 {
1971   TREE_REALPART (expr) = lto_input_tree (ib, data_in);
1972   TREE_IMAGPART (expr) = lto_input_tree (ib, data_in);
1973 }
1974
1975
1976 /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
1977    from input block IB.  DATA_IN contains tables and descriptors for the
1978    file being read.  */
1979
1980 static void
1981 lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block *ib,
1982                                          struct data_in *data_in, tree expr)
1983 {
1984   DECL_NAME (expr) = lto_input_tree (ib, data_in);
1985   DECL_CONTEXT (expr) = lto_input_tree (ib, data_in);
1986   DECL_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
1987 }
1988
1989
1990 /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
1991    input block IB.  DATA_IN contains tables and descriptors for the
1992    file being read.  */
1993
1994 static void
1995 lto_input_ts_decl_common_tree_pointers (struct lto_input_block *ib,
1996                                         struct data_in *data_in, tree expr)
1997 {
1998   DECL_SIZE (expr) = lto_input_tree (ib, data_in);
1999   DECL_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
2000
2001   if (TREE_CODE (expr) != FUNCTION_DECL
2002       && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
2003     DECL_INITIAL (expr) = lto_input_tree (ib, data_in);
2004
2005   DECL_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
2006   /* Do not stream DECL_ABSTRACT_ORIGIN.  We cannot handle debug information
2007      for early inlining so drop it on the floor instead of ICEing in
2008      dwarf2out.c.  */
2009
2010   if (TREE_CODE (expr) == PARM_DECL)
2011     TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2012
2013   if ((TREE_CODE (expr) == VAR_DECL
2014        || TREE_CODE (expr) == PARM_DECL)
2015       && DECL_HAS_VALUE_EXPR_P (expr))
2016     SET_DECL_VALUE_EXPR (expr, lto_input_tree (ib, data_in));
2017
2018   if (TREE_CODE (expr) == VAR_DECL)
2019     {
2020       tree dexpr = lto_input_tree (ib, data_in);
2021       if (dexpr)
2022         SET_DECL_DEBUG_EXPR (expr, dexpr);
2023     }
2024 }
2025
2026
2027 /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
2028    EXPR from input block IB.  DATA_IN contains tables and descriptors for the
2029    file being read.  */
2030
2031 static void
2032 lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block *ib,
2033                                             struct data_in *data_in, tree expr)
2034 {
2035   if (TREE_CODE (expr) == FUNCTION_DECL)
2036     {
2037       DECL_ARGUMENTS (expr) = lto_input_tree (ib, data_in);
2038       DECL_RESULT (expr) = lto_input_tree (ib, data_in);
2039     }
2040   DECL_VINDEX (expr) = lto_input_tree (ib, data_in);
2041 }
2042
2043
2044 /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
2045    from input block IB.  DATA_IN contains tables and descriptors for the
2046    file being read.  */
2047
2048 static void
2049 lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block *ib,
2050                                           struct data_in *data_in, tree expr)
2051 {
2052   tree id;
2053
2054   id = lto_input_tree (ib, data_in);
2055   if (id)
2056     {
2057       gcc_assert (TREE_CODE (id) == IDENTIFIER_NODE);
2058       SET_DECL_ASSEMBLER_NAME (expr, id);
2059     }
2060
2061   DECL_SECTION_NAME (expr) = lto_input_tree (ib, data_in);
2062   DECL_COMDAT_GROUP (expr) = lto_input_tree (ib, data_in);
2063 }
2064
2065
2066 /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
2067    input block IB.  DATA_IN contains tables and descriptors for the
2068    file being read.  */
2069
2070 static void
2071 lto_input_ts_field_decl_tree_pointers (struct lto_input_block *ib,
2072                                        struct data_in *data_in, tree expr)
2073 {
2074   DECL_FIELD_OFFSET (expr) = lto_input_tree (ib, data_in);
2075   DECL_BIT_FIELD_TYPE (expr) = lto_input_tree (ib, data_in);
2076   DECL_QUALIFIER (expr) = lto_input_tree (ib, data_in);
2077   DECL_FIELD_BIT_OFFSET (expr) = lto_input_tree (ib, data_in);
2078   DECL_FCONTEXT (expr) = lto_input_tree (ib, data_in);
2079   TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2080 }
2081
2082
2083 /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
2084    from input block IB.  DATA_IN contains tables and descriptors for the
2085    file being read.  */
2086
2087 static void
2088 lto_input_ts_function_decl_tree_pointers (struct lto_input_block *ib,
2089                                           struct data_in *data_in, tree expr)
2090 {
2091   /* DECL_STRUCT_FUNCTION is handled by lto_input_function.  FIXME lto,
2092      maybe it should be handled here?  */
2093   DECL_FUNCTION_PERSONALITY (expr) = lto_input_tree (ib, data_in);
2094   DECL_FUNCTION_SPECIFIC_TARGET (expr) = lto_input_tree (ib, data_in);
2095   DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = lto_input_tree (ib, data_in);
2096
2097   /* If the file contains a function with an EH personality set,
2098      then it was compiled with -fexceptions.  In that case, initialize
2099      the backend EH machinery.  */
2100   if (DECL_FUNCTION_PERSONALITY (expr))
2101     lto_init_eh ();
2102 }
2103
2104
2105 /* Read all pointer fields in the TS_TYPE structure of EXPR from input
2106    block IB.  DATA_IN contains tables and descriptors for the
2107    file being read.  */
2108
2109 static void
2110 lto_input_ts_type_tree_pointers (struct lto_input_block *ib,
2111                                  struct data_in *data_in, tree expr)
2112 {
2113   if (TREE_CODE (expr) == ENUMERAL_TYPE)
2114     TYPE_VALUES (expr) = lto_input_tree (ib, data_in);
2115   else if (TREE_CODE (expr) == ARRAY_TYPE)
2116     TYPE_DOMAIN (expr) = lto_input_tree (ib, data_in);
2117   else if (RECORD_OR_UNION_TYPE_P (expr))
2118     TYPE_FIELDS (expr) = lto_input_tree (ib, data_in);
2119   else if (TREE_CODE (expr) == FUNCTION_TYPE
2120            || TREE_CODE (expr) == METHOD_TYPE)
2121     TYPE_ARG_TYPES (expr) = lto_input_tree (ib, data_in);
2122
2123   TYPE_SIZE (expr) = lto_input_tree (ib, data_in);
2124   TYPE_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
2125   TYPE_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
2126   TYPE_NAME (expr) = lto_input_tree (ib, data_in);
2127   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
2128      TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO.  */
2129   if (!POINTER_TYPE_P (expr))
2130     TYPE_MINVAL (expr) = lto_input_tree (ib, data_in);
2131   TYPE_MAXVAL (expr) = lto_input_tree (ib, data_in);
2132   TYPE_MAIN_VARIANT (expr) = lto_input_tree (ib, data_in);
2133   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
2134      during fixup.  */
2135   if (RECORD_OR_UNION_TYPE_P (expr))
2136     TYPE_BINFO (expr) = lto_input_tree (ib, data_in);
2137   TYPE_CONTEXT (expr) = lto_input_tree (ib, data_in);
2138   /* TYPE_CANONICAL gets re-computed during type merging.  */
2139   TYPE_CANONICAL (expr) = NULL_TREE;
2140   TYPE_STUB_DECL (expr) = lto_input_tree (ib, data_in);
2141 }
2142
2143
2144 /* Read all pointer fields in the TS_LIST structure of EXPR from input
2145    block IB.  DATA_IN contains tables and descriptors for the
2146    file being read.  */
2147
2148 static void
2149 lto_input_ts_list_tree_pointers (struct lto_input_block *ib,
2150                                  struct data_in *data_in, tree expr)
2151 {
2152   TREE_PURPOSE (expr) = lto_input_tree (ib, data_in);
2153   TREE_VALUE (expr) = lto_input_tree (ib, data_in);
2154   TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2155 }
2156
2157
2158 /* Read all pointer fields in the TS_VEC structure of EXPR from input
2159    block IB.  DATA_IN contains tables and descriptors for the
2160    file being read.  */
2161
2162 static void
2163 lto_input_ts_vec_tree_pointers (struct lto_input_block *ib,
2164                                 struct data_in *data_in, tree expr)
2165 {
2166   int i;
2167
2168   /* Note that TREE_VEC_LENGTH was read by lto_materialize_tree to
2169      instantiate EXPR.  */
2170   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
2171     TREE_VEC_ELT (expr, i) = lto_input_tree (ib, data_in);
2172 }
2173
2174
2175 /* Read all pointer fields in the TS_EXP structure of EXPR from input
2176    block IB.  DATA_IN contains tables and descriptors for the
2177    file being read.  */
2178
2179
2180 static void
2181 lto_input_ts_exp_tree_pointers (struct lto_input_block *ib,
2182                                 struct data_in *data_in, tree expr)
2183 {
2184   int i, length;
2185   location_t loc;
2186
2187   length = lto_input_sleb128 (ib);
2188   gcc_assert (length == TREE_OPERAND_LENGTH (expr));
2189
2190   for (i = 0; i < length; i++)
2191     TREE_OPERAND (expr, i) = lto_input_tree (ib, data_in);
2192
2193   loc = lto_input_location (ib, data_in);
2194   SET_EXPR_LOCATION (expr, loc);
2195   TREE_BLOCK (expr) = lto_input_tree (ib, data_in);
2196 }
2197
2198
2199 /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
2200    block IB.  DATA_IN contains tables and descriptors for the
2201    file being read.  */
2202
2203 static void
2204 lto_input_ts_block_tree_pointers (struct lto_input_block *ib,
2205                                   struct data_in *data_in, tree expr)
2206 {
2207   /* Do not stream BLOCK_SOURCE_LOCATION.  We cannot handle debug information
2208      for early inlining so drop it on the floor instead of ICEing in
2209      dwarf2out.c.  */
2210   BLOCK_VARS (expr) = lto_input_chain (ib, data_in);
2211
2212   /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information
2213      for early inlining so drop it on the floor instead of ICEing in
2214      dwarf2out.c.  */
2215
2216   BLOCK_SUPERCONTEXT (expr) = lto_input_tree (ib, data_in);
2217   /* Do not stream BLOCK_ABSTRACT_ORIGIN.  We cannot handle debug information
2218      for early inlining so drop it on the floor instead of ICEing in
2219      dwarf2out.c.  */
2220   BLOCK_FRAGMENT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2221   BLOCK_FRAGMENT_CHAIN (expr) = lto_input_tree (ib, data_in);
2222   /* We re-compute BLOCK_SUBBLOCKS of our parent here instead
2223      of streaming it.  For non-BLOCK BLOCK_SUPERCONTEXTs we still
2224      stream the child relationship explicitly.  */
2225   if (BLOCK_SUPERCONTEXT (expr)
2226       && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == BLOCK)
2227     {
2228       BLOCK_CHAIN (expr) = BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr));
2229       BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr)) = expr;
2230     }
2231   /* The global block is rooted at the TU decl.  Hook it here to
2232      avoid the need to stream in this block during WPA time.  */
2233   else if (BLOCK_SUPERCONTEXT (expr)
2234            && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == TRANSLATION_UNIT_DECL)
2235     DECL_INITIAL (BLOCK_SUPERCONTEXT (expr)) = expr;
2236   /* The function-level block is connected at the time we read in
2237      function bodies for the same reason.  */
2238 }
2239
2240
2241 /* Read all pointer fields in the TS_BINFO structure of EXPR from input
2242    block IB.  DATA_IN contains tables and descriptors for the
2243    file being read.  */
2244
2245 static void
2246 lto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,
2247                                   struct data_in *data_in, tree expr)
2248 {
2249   unsigned i, len;
2250   tree t;
2251
2252   /* Note that the number of slots in EXPR was read in
2253      lto_materialize_tree when instantiating EXPR.  However, the
2254      vector is empty so we cannot rely on VEC_length to know how many
2255      elements to read.  So, this list is emitted as a 0-terminated
2256      list on the writer side.  */
2257   do
2258     {
2259       t = lto_input_tree (ib, data_in);
2260       if (t)
2261         VEC_quick_push (tree, BINFO_BASE_BINFOS (expr), t);
2262     }
2263   while (t);
2264
2265   BINFO_OFFSET (expr) = lto_input_tree (ib, data_in);
2266   BINFO_VTABLE (expr) = lto_input_tree (ib, data_in);
2267   BINFO_VIRTUALS (expr) = lto_input_tree (ib, data_in);
2268   BINFO_VPTR_FIELD (expr) = lto_input_tree (ib, data_in);
2269
2270   len = lto_input_uleb128 (ib);
2271   if (len > 0)
2272     {
2273       VEC_reserve_exact (tree, gc, BINFO_BASE_ACCESSES (expr), len);
2274       for (i = 0; i < len; i++)
2275         {
2276           tree a = lto_input_tree (ib, data_in);
2277           VEC_quick_push (tree, BINFO_BASE_ACCESSES (expr), a);
2278         }
2279     }
2280
2281   BINFO_INHERITANCE_CHAIN (expr) = lto_input_tree (ib, data_in);
2282   BINFO_SUBVTT_INDEX (expr) = lto_input_tree (ib, data_in);
2283   BINFO_VPTR_INDEX (expr) = lto_input_tree (ib, data_in);
2284 }
2285
2286
2287 /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
2288    input block IB.  DATA_IN contains tables and descriptors for the
2289    file being read.  */
2290
2291 static void
2292 lto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,
2293                                         struct data_in *data_in, tree expr)
2294 {
2295   unsigned i, len;
2296
2297   len = lto_input_uleb128 (ib);
2298   for (i = 0; i < len; i++)
2299     {
2300       tree index, value;
2301
2302       index = lto_input_tree (ib, data_in);
2303       value = lto_input_tree (ib, data_in);
2304       CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr), index, value);
2305     }
2306 }
2307
2308
2309 /* Input a TS_TARGET_OPTION tree from IB into EXPR.  */
2310
2311 static void
2312 lto_input_ts_target_option (struct lto_input_block *ib, tree expr)
2313 {
2314   unsigned i, len;
2315   struct bitpack_d bp;
2316   struct cl_target_option *t = TREE_TARGET_OPTION (expr);
2317
2318   bp = lto_input_bitpack (ib);
2319   len = sizeof (struct cl_target_option);
2320   for (i = 0; i < len; i++)
2321     ((unsigned char *)t)[i] = bp_unpack_value (&bp, 8);
2322   if (bp_unpack_value (&bp, 32) != 0x12345678)
2323     fatal_error ("cl_target_option size mismatch in LTO reader and writer");
2324 }
2325
2326 /* Input a TS_TRANSLATION_UNIT_DECL tree from IB and DATA_IN into EXPR.  */
2327
2328 static void
2329 lto_input_ts_translation_unit_decl_tree_pointers (struct lto_input_block *ib,
2330                                                   struct data_in *data_in,
2331                                                   tree expr)
2332 {
2333   TRANSLATION_UNIT_LANGUAGE (expr) = xstrdup (lto_input_string (data_in, ib));
2334   VEC_safe_push (tree, gc, all_translation_units, expr);
2335 }
2336
2337 /* Helper for lto_input_tree.  Read all pointer fields in EXPR from
2338    input block IB.  DATA_IN contains tables and descriptors for the
2339    file being read.  */
2340
2341 static void
2342 lto_input_tree_pointers (struct lto_input_block *ib, struct data_in *data_in,
2343                          tree expr)
2344 {
2345   enum tree_code code;
2346
2347   code = TREE_CODE (expr);
2348
2349   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
2350     lto_input_ts_common_tree_pointers (ib, data_in, expr);
2351
2352   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
2353     lto_input_ts_vector_tree_pointers (ib, data_in, expr);
2354
2355   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
2356     lto_input_ts_complex_tree_pointers (ib, data_in, expr);
2357
2358   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
2359     lto_input_ts_decl_minimal_tree_pointers (ib, data_in, expr);
2360
2361   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
2362     lto_input_ts_decl_common_tree_pointers (ib, data_in, expr);
2363
2364   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
2365     lto_input_ts_decl_non_common_tree_pointers (ib, data_in, expr);
2366
2367   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
2368     lto_input_ts_decl_with_vis_tree_pointers (ib, data_in, expr);
2369
2370   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
2371     lto_input_ts_field_decl_tree_pointers (ib, data_in, expr);
2372
2373   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
2374     lto_input_ts_function_decl_tree_pointers (ib, data_in, expr);
2375
2376   if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
2377     lto_input_ts_type_tree_pointers (ib, data_in, expr);
2378
2379   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
2380     lto_input_ts_list_tree_pointers (ib, data_in, expr);
2381
2382   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
2383     lto_input_ts_vec_tree_pointers (ib, data_in, expr);
2384
2385   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
2386     lto_input_ts_exp_tree_pointers (ib, data_in, expr);
2387
2388   if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
2389     {
2390       /* We only stream the version number of SSA names.  */
2391       gcc_unreachable ();
2392     }
2393
2394   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
2395     lto_input_ts_block_tree_pointers (ib, data_in, expr);
2396
2397   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
2398     lto_input_ts_binfo_tree_pointers (ib, data_in, expr);
2399
2400   if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
2401     {
2402       /* This should only appear in GENERIC.  */
2403       gcc_unreachable ();
2404     }
2405
2406   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
2407     lto_input_ts_constructor_tree_pointers (ib, data_in, expr);
2408
2409   if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
2410     {
2411       /* This should only appear in High GIMPLE.  */
2412       gcc_unreachable ();
2413     }
2414
2415   if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
2416     {
2417       sorry ("optimization options not supported yet");
2418     }
2419
2420   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
2421     lto_input_ts_target_option (ib, expr);
2422
2423   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
2424     lto_input_ts_translation_unit_decl_tree_pointers (ib, data_in, expr);
2425 }
2426
2427
2428 /* Register DECL with the global symbol table and change its
2429    name if necessary to avoid name clashes for static globals across
2430    different files.  */
2431
2432 static void
2433 lto_register_var_decl_in_symtab (struct data_in *data_in, tree decl)
2434 {
2435   tree context;
2436
2437   /* Variable has file scope, not local. Need to ensure static variables
2438      between different files don't clash unexpectedly.  */
2439   if (!TREE_PUBLIC (decl)
2440       && !((context = decl_function_context (decl))
2441            && auto_var_in_fn_p (decl, context)))
2442     {
2443       /* ??? We normally pre-mangle names before we serialize them
2444          out.  Here, in lto1, we do not know the language, and
2445          thus cannot do the mangling again. Instead, we just
2446          append a suffix to the mangled name.  The resulting name,
2447          however, is not a properly-formed mangled name, and will
2448          confuse any attempt to unmangle it.  */
2449       const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2450       char *label;
2451
2452       ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2453       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2454       rest_of_decl_compilation (decl, 1, 0);
2455
2456       VEC_safe_push (tree, gc, lto_global_var_decls, decl);
2457     }
2458
2459   /* If this variable has already been declared, queue the
2460      declaration for merging.  */
2461   if (TREE_PUBLIC (decl))
2462     {
2463       unsigned ix;
2464       if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2465         gcc_unreachable ();
2466       lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2467                                 data_in->file_data);
2468     }
2469 }
2470
2471
2472
2473 /* Register DECL with the global symbol table and change its
2474    name if necessary to avoid name clashes for static globals across
2475    different files.  DATA_IN contains descriptors and tables for the
2476    file being read.  */
2477
2478 static void
2479 lto_register_function_decl_in_symtab (struct data_in *data_in, tree decl)
2480 {
2481   /* Need to ensure static entities between different files
2482      don't clash unexpectedly.  */
2483   if (!TREE_PUBLIC (decl))
2484     {
2485       /* We must not use the DECL_ASSEMBLER_NAME macro here, as it
2486          may set the assembler name where it was previously empty.  */
2487       tree old_assembler_name = decl->decl_with_vis.assembler_name;
2488
2489       /* FIXME lto: We normally pre-mangle names before we serialize
2490          them out.  Here, in lto1, we do not know the language, and
2491          thus cannot do the mangling again. Instead, we just append a
2492          suffix to the mangled name.  The resulting name, however, is
2493          not a properly-formed mangled name, and will confuse any
2494          attempt to unmangle it.  */
2495       const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2496       char *label;
2497
2498       ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2499       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2500
2501       /* We may arrive here with the old assembler name not set
2502          if the function body is not needed, e.g., it has been
2503          inlined away and does not appear in the cgraph.  */
2504       if (old_assembler_name)
2505         {
2506           tree new_assembler_name = DECL_ASSEMBLER_NAME (decl);
2507
2508           /* Make the original assembler name available for later use.
2509              We may have used it to indicate the section within its
2510              object file where the function body may be found.
2511              FIXME lto: Find a better way to maintain the function decl
2512              to body section mapping so we don't need this hack.  */
2513           lto_record_renamed_decl (data_in->file_data,
2514                                    IDENTIFIER_POINTER (old_assembler_name),
2515                                    IDENTIFIER_POINTER (new_assembler_name));
2516
2517           /* Also register the reverse mapping so that we can find the
2518              new name given to an existing assembler name (used when
2519              restoring alias pairs in input_constructors_or_inits.  */
2520           lto_record_renamed_decl (data_in->file_data,
2521                                    IDENTIFIER_POINTER (new_assembler_name),
2522                                    IDENTIFIER_POINTER (old_assembler_name));
2523         }
2524     }
2525
2526   /* If this variable has already been declared, queue the
2527      declaration for merging.  */
2528   if (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl))
2529     {
2530       unsigned ix;
2531       if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2532         gcc_unreachable ();
2533       lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2534                                 data_in->file_data);
2535     }
2536 }
2537
2538
2539 /* Read an index IX from input block IB and return the tree node at
2540    DATA_IN->FILE_DATA->GLOBALS_INDEX[IX].  */
2541
2542 static tree
2543 lto_get_pickled_tree (struct lto_input_block *ib, struct data_in *data_in)
2544 {
2545   unsigned HOST_WIDE_INT ix;
2546   tree result;
2547   enum LTO_tags expected_tag;
2548
2549   ix = lto_input_uleb128 (ib);
2550   expected_tag = (enum LTO_tags) lto_input_uleb128 (ib);
2551
2552   result = lto_streamer_cache_get (data_in->reader_cache, ix);
2553   gcc_assert (result
2554               && TREE_CODE (result) == lto_tag_to_tree_code (expected_tag));
2555
2556   return result;
2557 }
2558
2559
2560 /* Read a code and class from input block IB and return the
2561    corresponding builtin.  DATA_IN is as in lto_input_tree.  */
2562
2563 static tree
2564 lto_get_builtin_tree (struct lto_input_block *ib, struct data_in *data_in)
2565 {
2566   enum built_in_class fclass;
2567   enum built_in_function fcode;
2568   const char *asmname;
2569   tree result;
2570
2571   fclass = (enum built_in_class) lto_input_uleb128 (ib);
2572   gcc_assert (fclass == BUILT_IN_NORMAL || fclass == BUILT_IN_MD);
2573
2574   fcode = (enum built_in_function) lto_input_uleb128 (ib);
2575
2576   if (fclass == BUILT_IN_NORMAL)
2577     {
2578       gcc_assert (fcode < END_BUILTINS);
2579       result = built_in_decls[fcode];
2580       gcc_assert (result);
2581     }
2582   else if (fclass == BUILT_IN_MD)
2583     {
2584       result = targetm.builtin_decl (fcode, true);
2585       if (!result || result == error_mark_node)
2586         fatal_error ("target specific builtin not available");
2587     }
2588   else
2589     gcc_unreachable ();
2590
2591   asmname = lto_input_string (data_in, ib);
2592   if (asmname)
2593     set_builtin_user_assembler_name (result, asmname);
2594
2595   lto_streamer_cache_append (data_in->reader_cache, result);
2596
2597   return result;
2598 }
2599
2600
2601 /* Read the physical representation of a tree node with tag TAG from
2602    input block IB using the per-file context in DATA_IN.  */
2603
2604 static tree
2605 lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
2606                enum LTO_tags tag)
2607 {
2608   tree result;
2609
2610   result = lto_materialize_tree (ib, data_in, tag);
2611
2612   /* Read all the pointer fields in RESULT.  */
2613   lto_input_tree_pointers (ib, data_in, result);
2614
2615   /* We should never try to instantiate an MD or NORMAL builtin here.  */
2616   if (TREE_CODE (result) == FUNCTION_DECL)
2617     gcc_assert (!lto_stream_as_builtin_p (result));
2618
2619   if (TREE_CODE (result) == VAR_DECL)
2620     lto_register_var_decl_in_symtab (data_in, result);
2621   else if (TREE_CODE (result) == FUNCTION_DECL && !DECL_BUILT_IN (result))
2622     lto_register_function_decl_in_symtab (data_in, result);
2623
2624   /* end_marker = */ lto_input_1_unsigned (ib);
2625
2626 #ifdef LTO_STREAMER_DEBUG
2627   /* Remove the mapping to RESULT's original address set by
2628      lto_materialize_tree.  */
2629   lto_orig_address_remove (result);
2630 #endif
2631
2632   return result;
2633 }
2634
2635
2636 /* Read and INTEGER_CST node from input block IB using the per-file
2637    context in DATA_IN.  */
2638
2639 static tree
2640 lto_input_integer_cst (struct lto_input_block *ib, struct data_in *data_in)
2641 {
2642   tree result, type;
2643   HOST_WIDE_INT low, high;
2644   bool overflow_p;
2645
2646   type = lto_input_tree (ib, data_in);
2647   overflow_p = (lto_input_1_unsigned (ib) != 0);
2648   low = lto_input_uleb128 (ib);
2649   high = lto_input_uleb128 (ib);
2650   result = build_int_cst_wide (type, low, high);
2651
2652   /* If the original constant had overflown, build a replica of RESULT to
2653      avoid modifying the shared constant returned by build_int_cst_wide.  */
2654   if (overflow_p)
2655     {
2656       result = copy_node (result);
2657       TREE_OVERFLOW (result) = 1;
2658     }
2659
2660   return result;
2661 }
2662
2663
2664 /* Read a tree from input block IB using the per-file context in
2665    DATA_IN.  This context is used, for example, to resolve references
2666    to previously read nodes.  */
2667
2668 tree
2669 lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
2670 {
2671   enum LTO_tags tag;
2672   tree result;
2673
2674   tag = input_record_start (ib);
2675   gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
2676
2677   if (tag == LTO_null)
2678     result = NULL_TREE;
2679   else if (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
2680     {
2681       /* If TAG is a reference to an indexable tree, the next value
2682          in IB is the index into the table where we expect to find
2683          that tree.  */
2684       result = lto_input_tree_ref (ib, data_in, cfun, tag);
2685     }
2686   else if (tag == LTO_tree_pickle_reference)
2687     {
2688       /* If TAG is a reference to a previously read tree, look it up in
2689          the reader cache.  */
2690       result = lto_get_pickled_tree (ib, data_in);
2691     }
2692   else if (tag == LTO_builtin_decl)
2693     {
2694       /* If we are going to read a built-in function, all we need is
2695          the code and class.  */
2696       result = lto_get_builtin_tree (ib, data_in);
2697     }
2698   else if (tag == lto_tree_code_to_tag (INTEGER_CST))
2699     {
2700       /* For integer constants we only need the type and its hi/low
2701          words.  */
2702       result = lto_input_integer_cst (ib, data_in);
2703     }
2704   else
2705     {
2706       /* Otherwise, materialize a new node from IB.  */
2707       result = lto_read_tree (ib, data_in, tag);
2708     }
2709
2710   return result;
2711 }
2712
2713
2714 /* Initialization for the LTO reader.  */
2715
2716 void
2717 lto_init_reader (void)
2718 {
2719   lto_streamer_init ();
2720
2721   memset (&lto_stats, 0, sizeof (lto_stats));
2722   bitmap_obstack_initialize (NULL);
2723
2724   file_name_hash_table = htab_create (37, hash_string_slot_node,
2725                                       eq_string_slot_node, free);
2726
2727   gimple_register_cfg_hooks ();
2728 }
2729
2730
2731 /* Create a new data_in object for FILE_DATA. STRINGS is the string
2732    table to use with LEN strings.  RESOLUTIONS is the vector of linker
2733    resolutions (NULL if not using a linker plugin).  */
2734
2735 struct data_in *
2736 lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
2737                     unsigned len,
2738                     VEC(ld_plugin_symbol_resolution_t,heap) *resolutions)
2739 {
2740   struct data_in *data_in = XCNEW (struct data_in);
2741   data_in->file_data = file_data;
2742   data_in->strings = strings;
2743   data_in->strings_len = len;
2744   data_in->globals_resolution = resolutions;
2745   data_in->reader_cache = lto_streamer_cache_create ();
2746
2747   return data_in;
2748 }
2749
2750
2751 /* Remove DATA_IN.  */
2752
2753 void
2754 lto_data_in_delete (struct data_in *data_in)
2755 {
2756   VEC_free (ld_plugin_symbol_resolution_t, heap, data_in->globals_resolution);
2757   lto_streamer_cache_delete (data_in->reader_cache);
2758   free (data_in->labels);
2759   free (data_in);
2760 }