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