gcc/lto-streamer-in.c

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