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