gcc/lto-streamer-in.c

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