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