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