gcc/lto-streamer-in.c

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