gcc/lto-streamer-in.c

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