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