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