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