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