gcc/lto-streamer-in.c

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