gcc/lto-streamer-in.c

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