gcc/lto-streamer-in.c

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