gcc/lto-streamer-in.c

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