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