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   int32_t cfg_offset;
1370   int32_t main_offset;
1371   int32_t 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       unsigned HOST_WIDE_INT off_align;
1600       DECL_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1601       DECL_NONADDRESSABLE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1602       off_align = (unsigned HOST_WIDE_INT) bp_unpack_value (bp, 8);
1603       SET_DECL_OFFSET_ALIGN (expr, off_align);
1604     }
1605
1606   if (TREE_CODE (expr) == RESULT_DECL
1607       || TREE_CODE (expr) == PARM_DECL
1608       || TREE_CODE (expr) == VAR_DECL)
1609     {
1610       DECL_BY_REFERENCE (expr) = (unsigned) bp_unpack_value (bp, 1);
1611       if (TREE_CODE (expr) == VAR_DECL
1612           || TREE_CODE (expr) == PARM_DECL)
1613         DECL_HAS_VALUE_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1614       DECL_RESTRICTED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1615     }
1616 }
1617
1618
1619 /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
1620    of expression EXPR from bitpack BP.  */
1621
1622 static void
1623 unpack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
1624 {
1625   DECL_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1626 }
1627
1628
1629 /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
1630    of expression EXPR from bitpack BP.  */
1631
1632 static void
1633 unpack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
1634 {
1635   DECL_DEFER_OUTPUT (expr) = (unsigned) bp_unpack_value (bp, 1);
1636   DECL_COMMON (expr) = (unsigned) bp_unpack_value (bp, 1);
1637   DECL_DLLIMPORT_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1638   DECL_WEAK (expr) = (unsigned) bp_unpack_value (bp, 1);
1639   DECL_SEEN_IN_BIND_EXPR_P (expr) = (unsigned) bp_unpack_value (bp,  1);
1640   DECL_COMDAT (expr) = (unsigned) bp_unpack_value (bp,  1);
1641   DECL_VISIBILITY (expr) = (enum symbol_visibility) bp_unpack_value (bp,  2);
1642   DECL_VISIBILITY_SPECIFIED (expr) = (unsigned) bp_unpack_value (bp,  1);
1643
1644   if (TREE_CODE (expr) == VAR_DECL)
1645     {
1646       DECL_HARD_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1647       DECL_IN_TEXT_SECTION (expr) = (unsigned) bp_unpack_value (bp, 1);
1648       DECL_IN_CONSTANT_POOL (expr) = (unsigned) bp_unpack_value (bp, 1);
1649       DECL_TLS_MODEL (expr) = (enum tls_model) bp_unpack_value (bp,  3);
1650     }
1651
1652   if (VAR_OR_FUNCTION_DECL_P (expr))
1653     {
1654       priority_type p;
1655       p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1656       SET_DECL_INIT_PRIORITY (expr, p);
1657     }
1658 }
1659
1660
1661 /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
1662    of expression EXPR from bitpack BP.  */
1663
1664 static void
1665 unpack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
1666 {
1667   DECL_FUNCTION_CODE (expr) = (enum built_in_function) bp_unpack_value (bp, 11);
1668   DECL_BUILT_IN_CLASS (expr) = (enum built_in_class) bp_unpack_value (bp, 2);
1669   DECL_STATIC_CONSTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1670   DECL_STATIC_DESTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1671   DECL_UNINLINABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1672   DECL_POSSIBLY_INLINED (expr) = (unsigned) bp_unpack_value (bp, 1);
1673   DECL_IS_NOVOPS (expr) = (unsigned) bp_unpack_value (bp, 1);
1674   DECL_IS_RETURNS_TWICE (expr) = (unsigned) bp_unpack_value (bp, 1);
1675   DECL_IS_MALLOC (expr) = (unsigned) bp_unpack_value (bp, 1);
1676   DECL_IS_OPERATOR_NEW (expr) = (unsigned) bp_unpack_value (bp, 1);
1677   DECL_DECLARED_INLINE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1678   DECL_STATIC_CHAIN (expr) = (unsigned) bp_unpack_value (bp, 1);
1679   DECL_NO_INLINE_WARNING_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1680   DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr)
1681                         = (unsigned) bp_unpack_value (bp, 1);
1682   DECL_NO_LIMIT_STACK (expr) = (unsigned) bp_unpack_value (bp, 1);
1683   DECL_DISREGARD_INLINE_LIMITS (expr) = (unsigned) bp_unpack_value (bp, 1);
1684   DECL_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1685   DECL_LOOPING_CONST_OR_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1686   if (DECL_STATIC_DESTRUCTOR (expr))
1687     {
1688        priority_type p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1689        SET_DECL_FINI_PRIORITY (expr, p);
1690     }
1691 }
1692
1693
1694 /* Unpack all the non-pointer fields of the TS_TYPE structure
1695    of expression EXPR from bitpack BP.  */
1696
1697 static void
1698 unpack_ts_type_value_fields (struct bitpack_d *bp, tree expr)
1699 {
1700   enum machine_mode mode;
1701
1702   TYPE_PRECISION (expr) = (unsigned) bp_unpack_value (bp, 10);
1703   mode = (enum machine_mode) bp_unpack_value (bp, 8);
1704   SET_TYPE_MODE (expr, mode);
1705   TYPE_STRING_FLAG (expr) = (unsigned) bp_unpack_value (bp, 1);
1706   TYPE_NO_FORCE_BLK (expr) = (unsigned) bp_unpack_value (bp, 1);
1707   TYPE_NEEDS_CONSTRUCTING (expr) = (unsigned) bp_unpack_value (bp, 1);
1708   if (RECORD_OR_UNION_TYPE_P (expr))
1709     TYPE_TRANSPARENT_AGGR (expr) = (unsigned) bp_unpack_value (bp, 1);
1710   TYPE_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1711   TYPE_RESTRICT (expr) = (unsigned) bp_unpack_value (bp, 1);
1712   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
1713         = (unsigned) bp_unpack_value (bp, 2);
1714   TYPE_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1715   TYPE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1716   TYPE_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1717   TYPE_ALIAS_SET (expr) = bp_unpack_value (bp, HOST_BITS_PER_INT);
1718 }
1719
1720
1721 /* Unpack all the non-pointer fields of the TS_BLOCK structure
1722    of expression EXPR from bitpack BP.  */
1723
1724 static void
1725 unpack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
1726 {
1727   BLOCK_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1728   BLOCK_NUMBER (expr) = (unsigned) bp_unpack_value (bp, 31);
1729 }
1730
1731 /* Unpack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL
1732    structure of expression EXPR from bitpack BP.  */
1733
1734 static void
1735 unpack_ts_translation_unit_decl_value_fields (struct bitpack_d *bp ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
1736 {
1737 }
1738
1739 /* Unpack all the non-pointer fields in EXPR into a bit pack.  */
1740
1741 static void
1742 unpack_value_fields (struct bitpack_d *bp, tree expr)
1743 {
1744   enum tree_code code;
1745
1746   code = TREE_CODE (expr);
1747
1748   /* Note that all these functions are highly sensitive to changes in
1749      the types and sizes of each of the fields being packed.  */
1750   unpack_ts_base_value_fields (bp, expr);
1751
1752   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
1753     unpack_ts_real_cst_value_fields (bp, expr);
1754
1755   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
1756     unpack_ts_fixed_cst_value_fields (bp, expr);
1757
1758   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1759     unpack_ts_decl_common_value_fields (bp, expr);
1760
1761   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
1762     unpack_ts_decl_wrtl_value_fields (bp, expr);
1763
1764   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1765     unpack_ts_decl_with_vis_value_fields (bp, expr);
1766
1767   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1768     unpack_ts_function_decl_value_fields (bp, expr);
1769
1770   if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
1771     unpack_ts_type_value_fields (bp, expr);
1772
1773   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1774     unpack_ts_block_value_fields (bp, expr);
1775
1776   if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
1777     {
1778       /* We only stream the version number of SSA names.  */
1779       gcc_unreachable ();
1780     }
1781
1782   if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
1783     {
1784       /* This is only used by GENERIC.  */
1785       gcc_unreachable ();
1786     }
1787
1788   if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
1789     {
1790       /* This is only used by High GIMPLE.  */
1791       gcc_unreachable ();
1792     }
1793
1794   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
1795     unpack_ts_translation_unit_decl_value_fields (bp, expr);
1796 }
1797
1798
1799 /* Materialize a new tree from input block IB using descriptors in
1800    DATA_IN.  The code for the new tree should match TAG.  Store in
1801    *IX_P the index into the reader cache where the new tree is stored.  */
1802
1803 static tree
1804 lto_materialize_tree (struct lto_input_block *ib, struct data_in *data_in,
1805                       enum LTO_tags tag, int *ix_p)
1806 {
1807   struct bitpack_d bp;
1808   enum tree_code code;
1809   tree result;
1810 #ifdef LTO_STREAMER_DEBUG
1811   HOST_WIDEST_INT orig_address_in_writer;
1812 #endif
1813   HOST_WIDE_INT ix;
1814
1815   result = NULL_TREE;
1816
1817   /* Read the header of the node we are about to create.  */
1818   ix = lto_input_sleb128 (ib);
1819   gcc_assert ((int) ix == ix);
1820   *ix_p = (int) ix;
1821
1822 #ifdef LTO_STREAMER_DEBUG
1823   /* Read the word representing the memory address for the tree
1824      as it was written by the writer.  This is useful when
1825      debugging differences between the writer and reader.  */
1826   orig_address_in_writer = lto_input_sleb128 (ib);
1827   gcc_assert ((intptr_t) orig_address_in_writer == orig_address_in_writer);
1828 #endif
1829
1830   code = lto_tag_to_tree_code (tag);
1831
1832   /* We should never see an SSA_NAME tree.  Only the version numbers of
1833      SSA names are ever written out.  See input_ssa_names.  */
1834   gcc_assert (code != SSA_NAME);
1835
1836   /* Instantiate a new tree using the header data.  */
1837   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1838     result = input_string_cst (data_in, ib);
1839   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1840     result = input_identifier (data_in, ib);
1841   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1842     {
1843       HOST_WIDE_INT len = lto_input_sleb128 (ib);
1844       result = make_tree_vec (len);
1845     }
1846   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1847     {
1848       unsigned HOST_WIDE_INT len = lto_input_uleb128 (ib);
1849       result = make_tree_binfo (len);
1850     }
1851   else
1852     {
1853       /* All other nodes can be materialized with a raw make_node
1854          call.  */
1855       result = make_node (code);
1856     }
1857
1858 #ifdef LTO_STREAMER_DEBUG
1859   /* Store the original address of the tree as seen by the writer
1860      in RESULT's aux field.  This is useful when debugging streaming
1861      problems.  This way, a debugging session can be started on
1862      both writer and reader with a breakpoint using this address
1863      value in both.  */
1864   lto_orig_address_map (result, (intptr_t) orig_address_in_writer);
1865 #endif
1866
1867   /* Read the bitpack of non-pointer values from IB.  */
1868   bp = lto_input_bitpack (ib);
1869
1870   /* The first word in BP contains the code of the tree that we
1871      are about to read.  */
1872   code = (enum tree_code) bp_unpack_value (&bp, 16);
1873   lto_tag_check (lto_tree_code_to_tag (code), tag);
1874
1875   /* Unpack all the value fields from BP.  */
1876   unpack_value_fields (&bp, result);
1877
1878   /* Enter RESULT in the reader cache.  This will make RESULT
1879      available so that circular references in the rest of the tree
1880      structure can be resolved in subsequent calls to lto_input_tree.  */
1881   lto_streamer_cache_insert_at (data_in->reader_cache, result, ix);
1882
1883   return result;
1884 }
1885
1886
1887 /* Read a chain of tree nodes from input block IB. DATA_IN contains
1888    tables and descriptors for the file being read.  */
1889
1890 static tree
1891 lto_input_chain (struct lto_input_block *ib, struct data_in *data_in)
1892 {
1893   int i, count;
1894   tree first, prev, curr;
1895
1896   first = prev = NULL_TREE;
1897   count = lto_input_sleb128 (ib);
1898   for (i = 0; i < count; i++)
1899     {
1900       curr = lto_input_tree (ib, data_in);
1901       if (prev)
1902         TREE_CHAIN (prev) = curr;
1903       else
1904         first = curr;
1905
1906       TREE_CHAIN (curr) = NULL_TREE;
1907       prev = curr;
1908     }
1909
1910   return first;
1911 }
1912
1913
1914 /* Read all pointer fields in the TS_COMMON structure of EXPR from input
1915    block IB.  DATA_IN contains tables and descriptors for the
1916    file being read.  */
1917
1918
1919 static void
1920 lto_input_ts_common_tree_pointers (struct lto_input_block *ib,
1921                                    struct data_in *data_in, tree expr)
1922 {
1923   if (TREE_CODE (expr) != IDENTIFIER_NODE)
1924     TREE_TYPE (expr) = lto_input_tree (ib, data_in);
1925 }
1926
1927
1928 /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
1929    block IB.  DATA_IN contains tables and descriptors for the
1930    file being read.  */
1931
1932 static void
1933 lto_input_ts_vector_tree_pointers (struct lto_input_block *ib,
1934                                    struct data_in *data_in, tree expr)
1935 {
1936   TREE_VECTOR_CST_ELTS (expr) = lto_input_chain (ib, data_in);
1937 }
1938
1939
1940 /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
1941    block IB.  DATA_IN contains tables and descriptors for the
1942    file being read.  */
1943
1944 static void
1945 lto_input_ts_complex_tree_pointers (struct lto_input_block *ib,
1946                                     struct data_in *data_in, tree expr)
1947 {
1948   TREE_REALPART (expr) = lto_input_tree (ib, data_in);
1949   TREE_IMAGPART (expr) = lto_input_tree (ib, data_in);
1950 }
1951
1952
1953 /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
1954    from input block IB.  DATA_IN contains tables and descriptors for the
1955    file being read.  */
1956
1957 static void
1958 lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block *ib,
1959                                          struct data_in *data_in, tree expr)
1960 {
1961   DECL_NAME (expr) = lto_input_tree (ib, data_in);
1962   DECL_CONTEXT (expr) = lto_input_tree (ib, data_in);
1963   DECL_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
1964 }
1965
1966
1967 /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
1968    input block IB.  DATA_IN contains tables and descriptors for the
1969    file being read.  */
1970
1971 static void
1972 lto_input_ts_decl_common_tree_pointers (struct lto_input_block *ib,
1973                                         struct data_in *data_in, tree expr)
1974 {
1975   DECL_SIZE (expr) = lto_input_tree (ib, data_in);
1976   DECL_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
1977
1978   if (TREE_CODE (expr) != FUNCTION_DECL
1979       && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
1980     DECL_INITIAL (expr) = lto_input_tree (ib, data_in);
1981
1982   DECL_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
1983   /* Do not stream DECL_ABSTRACT_ORIGIN.  We cannot handle debug information
1984      for early inlining so drop it on the floor instead of ICEing in
1985      dwarf2out.c.  */
1986
1987   if (TREE_CODE (expr) == PARM_DECL)
1988     TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
1989
1990   if ((TREE_CODE (expr) == VAR_DECL
1991        || TREE_CODE (expr) == PARM_DECL)
1992       && DECL_HAS_VALUE_EXPR_P (expr))
1993     SET_DECL_VALUE_EXPR (expr, lto_input_tree (ib, data_in));
1994
1995   if (TREE_CODE (expr) == VAR_DECL)
1996     {
1997       tree dexpr = lto_input_tree (ib, data_in);
1998       if (dexpr)
1999         SET_DECL_DEBUG_EXPR (expr, dexpr);
2000     }
2001 }
2002
2003
2004 /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
2005    EXPR from input block IB.  DATA_IN contains tables and descriptors for the
2006    file being read.  */
2007
2008 static void
2009 lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block *ib,
2010                                             struct data_in *data_in, tree expr)
2011 {
2012   if (TREE_CODE (expr) == FUNCTION_DECL)
2013     {
2014       DECL_ARGUMENTS (expr) = lto_input_tree (ib, data_in);
2015       DECL_RESULT (expr) = lto_input_tree (ib, data_in);
2016     }
2017   DECL_VINDEX (expr) = lto_input_tree (ib, data_in);
2018 }
2019
2020
2021 /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
2022    from input block IB.  DATA_IN contains tables and descriptors for the
2023    file being read.  */
2024
2025 static void
2026 lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block *ib,
2027                                           struct data_in *data_in, tree expr)
2028 {
2029   tree id;
2030
2031   id = lto_input_tree (ib, data_in);
2032   if (id)
2033     {
2034       gcc_assert (TREE_CODE (id) == IDENTIFIER_NODE);
2035       SET_DECL_ASSEMBLER_NAME (expr, id);
2036     }
2037
2038   DECL_SECTION_NAME (expr) = lto_input_tree (ib, data_in);
2039   DECL_COMDAT_GROUP (expr) = lto_input_tree (ib, data_in);
2040 }
2041
2042
2043 /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
2044    input block IB.  DATA_IN contains tables and descriptors for the
2045    file being read.  */
2046
2047 static void
2048 lto_input_ts_field_decl_tree_pointers (struct lto_input_block *ib,
2049                                        struct data_in *data_in, tree expr)
2050 {
2051   DECL_FIELD_OFFSET (expr) = lto_input_tree (ib, data_in);
2052   DECL_BIT_FIELD_TYPE (expr) = lto_input_tree (ib, data_in);
2053   DECL_QUALIFIER (expr) = lto_input_tree (ib, data_in);
2054   DECL_FIELD_BIT_OFFSET (expr) = lto_input_tree (ib, data_in);
2055   DECL_FCONTEXT (expr) = lto_input_tree (ib, data_in);
2056   TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2057 }
2058
2059
2060 /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
2061    from input block IB.  DATA_IN contains tables and descriptors for the
2062    file being read.  */
2063
2064 static void
2065 lto_input_ts_function_decl_tree_pointers (struct lto_input_block *ib,
2066                                           struct data_in *data_in, tree expr)
2067 {
2068   /* DECL_STRUCT_FUNCTION is handled by lto_input_function.  FIXME lto,
2069      maybe it should be handled here?  */
2070   DECL_FUNCTION_PERSONALITY (expr) = lto_input_tree (ib, data_in);
2071   DECL_FUNCTION_SPECIFIC_TARGET (expr) = lto_input_tree (ib, data_in);
2072   DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = lto_input_tree (ib, data_in);
2073
2074   /* If the file contains a function with an EH personality set,
2075      then it was compiled with -fexceptions.  In that case, initialize
2076      the backend EH machinery.  */
2077   if (DECL_FUNCTION_PERSONALITY (expr))
2078     lto_init_eh ();
2079 }
2080
2081
2082 /* Read all pointer fields in the TS_TYPE structure of EXPR from input
2083    block IB.  DATA_IN contains tables and descriptors for the
2084    file being read.  */
2085
2086 static void
2087 lto_input_ts_type_tree_pointers (struct lto_input_block *ib,
2088                                  struct data_in *data_in, tree expr)
2089 {
2090   if (TREE_CODE (expr) == ENUMERAL_TYPE)
2091     TYPE_VALUES (expr) = lto_input_tree (ib, data_in);
2092   else if (TREE_CODE (expr) == ARRAY_TYPE)
2093     TYPE_DOMAIN (expr) = lto_input_tree (ib, data_in);
2094   else if (RECORD_OR_UNION_TYPE_P (expr))
2095     TYPE_FIELDS (expr) = lto_input_tree (ib, data_in);
2096   else if (TREE_CODE (expr) == FUNCTION_TYPE
2097            || TREE_CODE (expr) == METHOD_TYPE)
2098     TYPE_ARG_TYPES (expr) = lto_input_tree (ib, data_in);
2099
2100   TYPE_SIZE (expr) = lto_input_tree (ib, data_in);
2101   TYPE_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
2102   TYPE_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
2103   TYPE_NAME (expr) = lto_input_tree (ib, data_in);
2104   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
2105      TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO.  */
2106   if (!POINTER_TYPE_P (expr))
2107     TYPE_MINVAL (expr) = lto_input_tree (ib, data_in);
2108   TYPE_MAXVAL (expr) = lto_input_tree (ib, data_in);
2109   TYPE_MAIN_VARIANT (expr) = lto_input_tree (ib, data_in);
2110   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
2111      during fixup.  */
2112   if (RECORD_OR_UNION_TYPE_P (expr))
2113     TYPE_BINFO (expr) = lto_input_tree (ib, data_in);
2114   TYPE_CONTEXT (expr) = lto_input_tree (ib, data_in);
2115   /* TYPE_CANONICAL gets re-computed during type merging.  */
2116   TYPE_CANONICAL (expr) = NULL_TREE;
2117   TYPE_STUB_DECL (expr) = lto_input_tree (ib, data_in);
2118 }
2119
2120
2121 /* Read all pointer fields in the TS_LIST structure of EXPR from input
2122    block IB.  DATA_IN contains tables and descriptors for the
2123    file being read.  */
2124
2125 static void
2126 lto_input_ts_list_tree_pointers (struct lto_input_block *ib,
2127                                  struct data_in *data_in, tree expr)
2128 {
2129   TREE_PURPOSE (expr) = lto_input_tree (ib, data_in);
2130   TREE_VALUE (expr) = lto_input_tree (ib, data_in);
2131   TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2132 }
2133
2134
2135 /* Read all pointer fields in the TS_VEC structure of EXPR from input
2136    block IB.  DATA_IN contains tables and descriptors for the
2137    file being read.  */
2138
2139 static void
2140 lto_input_ts_vec_tree_pointers (struct lto_input_block *ib,
2141                                 struct data_in *data_in, tree expr)
2142 {
2143   int i;
2144
2145   /* Note that TREE_VEC_LENGTH was read by lto_materialize_tree to
2146      instantiate EXPR.  */
2147   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
2148     TREE_VEC_ELT (expr, i) = lto_input_tree (ib, data_in);
2149 }
2150
2151
2152 /* Read all pointer fields in the TS_EXP structure of EXPR from input
2153    block IB.  DATA_IN contains tables and descriptors for the
2154    file being read.  */
2155
2156
2157 static void
2158 lto_input_ts_exp_tree_pointers (struct lto_input_block *ib,
2159                                 struct data_in *data_in, tree expr)
2160 {
2161   int i, length;
2162   location_t loc;
2163
2164   length = lto_input_sleb128 (ib);
2165   gcc_assert (length == TREE_OPERAND_LENGTH (expr));
2166
2167   for (i = 0; i < length; i++)
2168     TREE_OPERAND (expr, i) = lto_input_tree (ib, data_in);
2169
2170   loc = lto_input_location (ib, data_in);
2171   SET_EXPR_LOCATION (expr, loc);
2172   TREE_BLOCK (expr) = lto_input_tree (ib, data_in);
2173 }
2174
2175
2176 /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
2177    block IB.  DATA_IN contains tables and descriptors for the
2178    file being read.  */
2179
2180 static void
2181 lto_input_ts_block_tree_pointers (struct lto_input_block *ib,
2182                                   struct data_in *data_in, tree expr)
2183 {
2184   /* Do not stream BLOCK_SOURCE_LOCATION.  We cannot handle debug information
2185      for early inlining so drop it on the floor instead of ICEing in
2186      dwarf2out.c.  */
2187   BLOCK_VARS (expr) = lto_input_chain (ib, data_in);
2188
2189   /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information
2190      for early inlining so drop it on the floor instead of ICEing in
2191      dwarf2out.c.  */
2192
2193   BLOCK_SUPERCONTEXT (expr) = lto_input_tree (ib, data_in);
2194   /* Do not stream BLOCK_ABSTRACT_ORIGIN.  We cannot handle debug information
2195      for early inlining so drop it on the floor instead of ICEing in
2196      dwarf2out.c.  */
2197   BLOCK_FRAGMENT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2198   BLOCK_FRAGMENT_CHAIN (expr) = lto_input_tree (ib, data_in);
2199   /* We re-compute BLOCK_SUBBLOCKS of our parent here instead
2200      of streaming it.  For non-BLOCK BLOCK_SUPERCONTEXTs we still
2201      stream the child relationship explicitly.  */
2202   if (BLOCK_SUPERCONTEXT (expr)
2203       && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == BLOCK)
2204     {
2205       BLOCK_CHAIN (expr) = BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr));
2206       BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr)) = expr;
2207     }
2208   /* The global block is rooted at the TU decl.  Hook it here to
2209      avoid the need to stream in this block during WPA time.  */
2210   else if (BLOCK_SUPERCONTEXT (expr)
2211            && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == TRANSLATION_UNIT_DECL)
2212     DECL_INITIAL (BLOCK_SUPERCONTEXT (expr)) = expr;
2213   /* The function-level block is connected at the time we read in
2214      function bodies for the same reason.  */
2215 }
2216
2217
2218 /* Read all pointer fields in the TS_BINFO structure of EXPR from input
2219    block IB.  DATA_IN contains tables and descriptors for the
2220    file being read.  */
2221
2222 static void
2223 lto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,
2224                                   struct data_in *data_in, tree expr)
2225 {
2226   unsigned i, len;
2227   tree t;
2228
2229   /* Note that the number of slots in EXPR was read in
2230      lto_materialize_tree when instantiating EXPR.  However, the
2231      vector is empty so we cannot rely on VEC_length to know how many
2232      elements to read.  So, this list is emitted as a 0-terminated
2233      list on the writer side.  */
2234   do
2235     {
2236       t = lto_input_tree (ib, data_in);
2237       if (t)
2238         VEC_quick_push (tree, BINFO_BASE_BINFOS (expr), t);
2239     }
2240   while (t);
2241
2242   BINFO_OFFSET (expr) = lto_input_tree (ib, data_in);
2243   BINFO_VTABLE (expr) = lto_input_tree (ib, data_in);
2244   BINFO_VIRTUALS (expr) = lto_input_tree (ib, data_in);
2245   BINFO_VPTR_FIELD (expr) = lto_input_tree (ib, data_in);
2246
2247   len = lto_input_uleb128 (ib);
2248   if (len > 0)
2249     {
2250       VEC_reserve_exact (tree, gc, BINFO_BASE_ACCESSES (expr), len);
2251       for (i = 0; i < len; i++)
2252         {
2253           tree a = lto_input_tree (ib, data_in);
2254           VEC_quick_push (tree, BINFO_BASE_ACCESSES (expr), a);
2255         }
2256     }
2257
2258   BINFO_INHERITANCE_CHAIN (expr) = lto_input_tree (ib, data_in);
2259   BINFO_SUBVTT_INDEX (expr) = lto_input_tree (ib, data_in);
2260   BINFO_VPTR_INDEX (expr) = lto_input_tree (ib, data_in);
2261 }
2262
2263
2264 /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
2265    input block IB.  DATA_IN contains tables and descriptors for the
2266    file being read.  */
2267
2268 static void
2269 lto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,
2270                                         struct data_in *data_in, tree expr)
2271 {
2272   unsigned i, len;
2273
2274   len = lto_input_uleb128 (ib);
2275   for (i = 0; i < len; i++)
2276     {
2277       tree index, value;
2278
2279       index = lto_input_tree (ib, data_in);
2280       value = lto_input_tree (ib, data_in);
2281       CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr), index, value);
2282     }
2283 }
2284
2285
2286 /* Input a TS_TARGET_OPTION tree from IB into EXPR.  */
2287
2288 static void
2289 lto_input_ts_target_option (struct lto_input_block *ib, tree expr)
2290 {
2291   unsigned i, len;
2292   struct bitpack_d bp;
2293   struct cl_target_option *t = TREE_TARGET_OPTION (expr);
2294
2295   bp = lto_input_bitpack (ib);
2296   len = sizeof (struct cl_target_option);
2297   for (i = 0; i < len; i++)
2298     ((unsigned char *)t)[i] = bp_unpack_value (&bp, 8);
2299   if (bp_unpack_value (&bp, 32) != 0x12345678)
2300     fatal_error ("cl_target_option size mismatch in LTO reader and writer");
2301 }
2302
2303 /* Input a TS_TRANSLATION_UNIT_DECL tree from IB and DATA_IN into EXPR.  */
2304
2305 static void
2306 lto_input_ts_translation_unit_decl_tree_pointers (struct lto_input_block *ib,
2307                                                   struct data_in *data_in,
2308                                                   tree expr)
2309 {
2310   TRANSLATION_UNIT_LANGUAGE (expr) = xstrdup (input_string (data_in, ib));
2311   VEC_safe_push (tree, gc, all_translation_units, expr);
2312 }
2313
2314 /* Helper for lto_input_tree.  Read all pointer fields in EXPR from
2315    input block IB.  DATA_IN contains tables and descriptors for the
2316    file being read.  */
2317
2318 static void
2319 lto_input_tree_pointers (struct lto_input_block *ib, struct data_in *data_in,
2320                          tree expr)
2321 {
2322   enum tree_code code;
2323
2324   code = TREE_CODE (expr);
2325
2326   if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
2327     lto_input_ts_common_tree_pointers (ib, data_in, expr);
2328
2329   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
2330     lto_input_ts_vector_tree_pointers (ib, data_in, expr);
2331
2332   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
2333     lto_input_ts_complex_tree_pointers (ib, data_in, expr);
2334
2335   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
2336     lto_input_ts_decl_minimal_tree_pointers (ib, data_in, expr);
2337
2338   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
2339     lto_input_ts_decl_common_tree_pointers (ib, data_in, expr);
2340
2341   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
2342     lto_input_ts_decl_non_common_tree_pointers (ib, data_in, expr);
2343
2344   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
2345     lto_input_ts_decl_with_vis_tree_pointers (ib, data_in, expr);
2346
2347   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
2348     lto_input_ts_field_decl_tree_pointers (ib, data_in, expr);
2349
2350   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
2351     lto_input_ts_function_decl_tree_pointers (ib, data_in, expr);
2352
2353   if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
2354     lto_input_ts_type_tree_pointers (ib, data_in, expr);
2355
2356   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
2357     lto_input_ts_list_tree_pointers (ib, data_in, expr);
2358
2359   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
2360     lto_input_ts_vec_tree_pointers (ib, data_in, expr);
2361
2362   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
2363     lto_input_ts_exp_tree_pointers (ib, data_in, expr);
2364
2365   if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
2366     {
2367       /* We only stream the version number of SSA names.  */
2368       gcc_unreachable ();
2369     }
2370
2371   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
2372     lto_input_ts_block_tree_pointers (ib, data_in, expr);
2373
2374   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
2375     lto_input_ts_binfo_tree_pointers (ib, data_in, expr);
2376
2377   if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
2378     {
2379       /* This should only appear in GENERIC.  */
2380       gcc_unreachable ();
2381     }
2382
2383   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
2384     lto_input_ts_constructor_tree_pointers (ib, data_in, expr);
2385
2386   if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
2387     {
2388       /* This should only appear in High GIMPLE.  */
2389       gcc_unreachable ();
2390     }
2391
2392   if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
2393     {
2394       sorry ("optimization options not supported yet");
2395     }
2396
2397   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
2398     lto_input_ts_target_option (ib, expr);
2399
2400   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
2401     lto_input_ts_translation_unit_decl_tree_pointers (ib, data_in, expr);
2402 }
2403
2404
2405 /* Register DECL with the global symbol table and change its
2406    name if necessary to avoid name clashes for static globals across
2407    different files.  */
2408
2409 static void
2410 lto_register_var_decl_in_symtab (struct data_in *data_in, tree decl)
2411 {
2412   tree context;
2413
2414   /* Variable has file scope, not local. Need to ensure static variables
2415      between different files don't clash unexpectedly.  */
2416   if (!TREE_PUBLIC (decl)
2417       && !((context = decl_function_context (decl))
2418            && auto_var_in_fn_p (decl, context)))
2419     {
2420       /* ??? We normally pre-mangle names before we serialize them
2421          out.  Here, in lto1, we do not know the language, and
2422          thus cannot do the mangling again. Instead, we just
2423          append a suffix to the mangled name.  The resulting name,
2424          however, is not a properly-formed mangled name, and will
2425          confuse any attempt to unmangle it.  */
2426       const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2427       char *label;
2428
2429       ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2430       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2431       rest_of_decl_compilation (decl, 1, 0);
2432
2433       VEC_safe_push (tree, gc, lto_global_var_decls, decl);
2434     }
2435
2436   /* If this variable has already been declared, queue the
2437      declaration for merging.  */
2438   if (TREE_PUBLIC (decl))
2439     {
2440       int ix;
2441       if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2442         gcc_unreachable ();
2443       lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2444                                 data_in->file_data);
2445     }
2446 }
2447
2448
2449
2450 /* Register DECL with the global symbol table and change its
2451    name if necessary to avoid name clashes for static globals across
2452    different files.  DATA_IN contains descriptors and tables for the
2453    file being read.  */
2454
2455 static void
2456 lto_register_function_decl_in_symtab (struct data_in *data_in, tree decl)
2457 {
2458   /* Need to ensure static entities between different files
2459      don't clash unexpectedly.  */
2460   if (!TREE_PUBLIC (decl))
2461     {
2462       /* We must not use the DECL_ASSEMBLER_NAME macro here, as it
2463          may set the assembler name where it was previously empty.  */
2464       tree old_assembler_name = decl->decl_with_vis.assembler_name;
2465
2466       /* FIXME lto: We normally pre-mangle names before we serialize
2467          them out.  Here, in lto1, we do not know the language, and
2468          thus cannot do the mangling again. Instead, we just append a
2469          suffix to the mangled name.  The resulting name, however, is
2470          not a properly-formed mangled name, and will confuse any
2471          attempt to unmangle it.  */
2472       const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2473       char *label;
2474
2475       ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2476       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2477
2478       /* We may arrive here with the old assembler name not set
2479          if the function body is not needed, e.g., it has been
2480          inlined away and does not appear in the cgraph.  */
2481       if (old_assembler_name)
2482         {
2483           tree new_assembler_name = DECL_ASSEMBLER_NAME (decl);
2484
2485           /* Make the original assembler name available for later use.
2486              We may have used it to indicate the section within its
2487              object file where the function body may be found.
2488              FIXME lto: Find a better way to maintain the function decl
2489              to body section mapping so we don't need this hack.  */
2490           lto_record_renamed_decl (data_in->file_data,
2491                                    IDENTIFIER_POINTER (old_assembler_name),
2492                                    IDENTIFIER_POINTER (new_assembler_name));
2493
2494           /* Also register the reverse mapping so that we can find the
2495              new name given to an existing assembler name (used when
2496              restoring alias pairs in input_constructors_or_inits.  */
2497           lto_record_renamed_decl (data_in->file_data,
2498                                    IDENTIFIER_POINTER (new_assembler_name),
2499                                    IDENTIFIER_POINTER (old_assembler_name));
2500         }
2501     }
2502
2503   /* If this variable has already been declared, queue the
2504      declaration for merging.  */
2505   if (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl))
2506     {
2507       int ix;
2508       if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2509         gcc_unreachable ();
2510       lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2511                                 data_in->file_data);
2512     }
2513 }
2514
2515
2516 /* Read an index IX from input block IB and return the tree node at
2517    DATA_IN->FILE_DATA->GLOBALS_INDEX[IX].  */
2518
2519 static tree
2520 lto_get_pickled_tree (struct lto_input_block *ib, struct data_in *data_in)
2521 {
2522   HOST_WIDE_INT ix;
2523   tree result;
2524   enum LTO_tags expected_tag;
2525   unsigned HOST_WIDE_INT orig_offset;
2526
2527   ix = lto_input_sleb128 (ib);
2528   expected_tag = (enum LTO_tags) lto_input_uleb128 (ib);
2529
2530   orig_offset = lto_input_uleb128 (ib);
2531   gcc_assert (orig_offset == (unsigned) orig_offset);
2532
2533   result = lto_streamer_cache_get (data_in->reader_cache, ix);
2534   if (result == NULL_TREE)
2535     {
2536       /* We have not yet read the cache slot IX.  Go to the offset
2537          in the stream where the physical tree node is, and materialize
2538          it from there.  */
2539       struct lto_input_block fwd_ib;
2540
2541       /* If we are trying to go back in the stream, something is wrong.
2542          We should've read the node at the earlier position already.  */
2543       if (ib->p >= orig_offset)
2544         internal_error ("bytecode stream: tried to jump backwards in the "
2545                         "stream");
2546
2547       LTO_INIT_INPUT_BLOCK (fwd_ib, ib->data, orig_offset, ib->len);
2548       result = lto_input_tree (&fwd_ib, data_in);
2549     }
2550
2551   gcc_assert (result
2552               && TREE_CODE (result) == lto_tag_to_tree_code (expected_tag));
2553
2554   return result;
2555 }
2556
2557
2558 /* Read a code and class from input block IB and return the
2559    corresponding builtin.  DATA_IN is as in lto_input_tree.  */
2560
2561 static tree
2562 lto_get_builtin_tree (struct lto_input_block *ib, struct data_in *data_in)
2563 {
2564   enum built_in_class fclass;
2565   enum built_in_function fcode;
2566   const char *asmname;
2567   tree result;
2568   int ix;
2569
2570   fclass = (enum built_in_class) lto_input_uleb128 (ib);
2571   gcc_assert (fclass == BUILT_IN_NORMAL || fclass == BUILT_IN_MD);
2572
2573   fcode = (enum built_in_function) lto_input_uleb128 (ib);
2574
2575   ix = lto_input_sleb128 (ib);
2576   gcc_assert (ix == (int) ix);
2577
2578   if (fclass == BUILT_IN_NORMAL)
2579     {
2580       gcc_assert (fcode < END_BUILTINS);
2581       result = built_in_decls[fcode];
2582       gcc_assert (result);
2583     }
2584   else if (fclass == BUILT_IN_MD)
2585     {
2586       result = targetm.builtin_decl (fcode, true);
2587       if (!result || result == error_mark_node)
2588         fatal_error ("target specific builtin not available");
2589     }
2590   else
2591     gcc_unreachable ();
2592
2593   asmname = input_string (data_in, ib);
2594   if (asmname)
2595     set_builtin_user_assembler_name (result, asmname);
2596
2597   lto_streamer_cache_insert_at (data_in->reader_cache, result, ix);
2598
2599   return result;
2600 }
2601
2602
2603 /* Read the physical representation of a tree node with tag TAG from
2604    input block IB using the per-file context in DATA_IN.  */
2605
2606 static tree
2607 lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
2608                enum LTO_tags tag)
2609 {
2610   tree result;
2611   int ix;
2612
2613   result = lto_materialize_tree (ib, data_in, tag, &ix);
2614
2615   /* Read all the pointer fields in RESULT.  */
2616   lto_input_tree_pointers (ib, data_in, result);
2617
2618   /* We should never try to instantiate an MD or NORMAL builtin here.  */
2619   if (TREE_CODE (result) == FUNCTION_DECL)
2620     gcc_assert (!lto_stream_as_builtin_p (result));
2621
2622   if (TREE_CODE (result) == VAR_DECL)
2623     lto_register_var_decl_in_symtab (data_in, result);
2624   else if (TREE_CODE (result) == FUNCTION_DECL && !DECL_BUILT_IN (result))
2625     lto_register_function_decl_in_symtab (data_in, result);
2626
2627   /* end_marker = */ lto_input_1_unsigned (ib);
2628
2629 #ifdef LTO_STREAMER_DEBUG
2630   /* Remove the mapping to RESULT's original address set by
2631      lto_materialize_tree.  */
2632   lto_orig_address_remove (result);
2633 #endif
2634
2635   return result;
2636 }
2637
2638
2639 /* Read and INTEGER_CST node from input block IB using the per-file
2640    context in DATA_IN.  */
2641
2642 static tree
2643 lto_input_integer_cst (struct lto_input_block *ib, struct data_in *data_in)
2644 {
2645   tree result, type;
2646   HOST_WIDE_INT low, high;
2647   bool overflow_p;
2648
2649   type = lto_input_tree (ib, data_in);
2650   overflow_p = (lto_input_1_unsigned (ib) != 0);
2651   low = lto_input_uleb128 (ib);
2652   high = lto_input_uleb128 (ib);
2653   result = build_int_cst_wide (type, low, high);
2654
2655   /* If the original constant had overflown, build a replica of RESULT to
2656      avoid modifying the shared constant returned by build_int_cst_wide.  */
2657   if (overflow_p)
2658     {
2659       result = copy_node (result);
2660       TREE_OVERFLOW (result) = 1;
2661     }
2662
2663   return result;
2664 }
2665
2666
2667 /* Read a tree from input block IB using the per-file context in
2668    DATA_IN.  This context is used, for example, to resolve references
2669    to previously read nodes.  */
2670
2671 tree
2672 lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
2673 {
2674   enum LTO_tags tag;
2675   tree result;
2676
2677   tag = input_record_start (ib);
2678   gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
2679
2680   if (tag == LTO_null)
2681     result = NULL_TREE;
2682   else if (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
2683     {
2684       /* If TAG is a reference to an indexable tree, the next value
2685          in IB is the index into the table where we expect to find
2686          that tree.  */
2687       result = lto_input_tree_ref (ib, data_in, cfun, tag);
2688     }
2689   else if (tag == LTO_tree_pickle_reference)
2690     {
2691       /* If TAG is a reference to a previously read tree, look it up in
2692          the reader cache.  */
2693       result = lto_get_pickled_tree (ib, data_in);
2694     }
2695   else if (tag == LTO_builtin_decl)
2696     {
2697       /* If we are going to read a built-in function, all we need is
2698          the code and class.  */
2699       result = lto_get_builtin_tree (ib, data_in);
2700     }
2701   else if (tag == lto_tree_code_to_tag (INTEGER_CST))
2702     {
2703       /* For integer constants we only need the type and its hi/low
2704          words.  */
2705       result = lto_input_integer_cst (ib, data_in);
2706     }
2707   else
2708     {
2709       /* Otherwise, materialize a new node from IB.  */
2710       result = lto_read_tree (ib, data_in, tag);
2711     }
2712
2713   return result;
2714 }
2715
2716
2717 /* Initialization for the LTO reader.  */
2718
2719 void
2720 lto_init_reader (void)
2721 {
2722   lto_streamer_init ();
2723
2724   memset (&lto_stats, 0, sizeof (lto_stats));
2725   bitmap_obstack_initialize (NULL);
2726
2727   file_name_hash_table = htab_create (37, hash_string_slot_node,
2728                                       eq_string_slot_node, free);
2729
2730   gimple_register_cfg_hooks ();
2731 }
2732
2733
2734 /* Create a new data_in object for FILE_DATA. STRINGS is the string
2735    table to use with LEN strings.  RESOLUTIONS is the vector of linker
2736    resolutions (NULL if not using a linker plugin).  */
2737
2738 struct data_in *
2739 lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
2740                     unsigned len,
2741                     VEC(ld_plugin_symbol_resolution_t,heap) *resolutions)
2742 {
2743   struct data_in *data_in = XCNEW (struct data_in);
2744   data_in->file_data = file_data;
2745   data_in->strings = strings;
2746   data_in->strings_len = len;
2747   data_in->globals_resolution = resolutions;
2748   data_in->reader_cache = lto_streamer_cache_create ();
2749
2750   return data_in;
2751 }
2752
2753
2754 /* Remove DATA_IN.  */
2755
2756 void
2757 lto_data_in_delete (struct data_in *data_in)
2758 {
2759   VEC_free (ld_plugin_symbol_resolution_t, heap, data_in->globals_resolution);
2760   lto_streamer_cache_delete (data_in->reader_cache);
2761   free (data_in->labels);
2762   free (data_in);
2763 }