gcc/lto-streamer-in.c

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