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