1 /* Write the GIMPLE representation to a file stream. 2 3 Copyright (C) 2009-2018 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 "backend.h" 27 #include "target.h" 28 #include "rtl.h" 29 #include "tree.h" 30 #include "gimple.h" 31 #include "tree-pass.h" 32 #include "ssa.h" 33 #include "gimple-streamer.h" 34 #include "alias.h" 35 #include "stor-layout.h" 36 #include "gimple-iterator.h" 37 #include "except.h" 38 #include "lto-symtab.h" 39 #include "cgraph.h" 40 #include "cfgloop.h" 41 #include "builtins.h" 42 #include "gomp-constants.h" 43 #include "debug.h" 44 #include "omp-offload.h" 45 46 47 static void lto_write_tree (struct output_block*, tree, bool); 48 49 /* Clear the line info stored in DATA_IN. */ 50 51 static void 52 clear_line_info (struct output_block *ob) 53 { 54 ob->current_file = NULL; 55 ob->current_line = 0; 56 ob->current_col = 0; 57 ob->current_sysp = false; 58 } 59 60 61 /* Create the output block and return it. SECTION_TYPE is 62 LTO_section_function_body or LTO_static_initializer. */ 63 64 struct output_block * 65 create_output_block (enum lto_section_type section_type) 66 { 67 struct output_block *ob = XCNEW (struct output_block); 68 69 ob->section_type = section_type; 70 ob->decl_state = lto_get_out_decl_state (); 71 ob->main_stream = XCNEW (struct lto_output_stream); 72 ob->string_stream = XCNEW (struct lto_output_stream); 73 ob->writer_cache = streamer_tree_cache_create (!flag_wpa, true, false); 74 75 if (section_type == LTO_section_function_body) 76 ob->cfg_stream = XCNEW (struct lto_output_stream); 77 78 clear_line_info (ob); 79 80 ob->string_hash_table = new hash_table<string_slot_hasher> (37); 81 gcc_obstack_init (&ob->obstack); 82 83 return ob; 84 } 85 86 87 /* Destroy the output block OB. */ 88 89 void 90 destroy_output_block (struct output_block *ob) 91 { 92 enum lto_section_type section_type = ob->section_type; 93 94 delete ob->string_hash_table; 95 ob->string_hash_table = NULL; 96 97 free (ob->main_stream); 98 free (ob->string_stream); 99 if (section_type == LTO_section_function_body) 100 free (ob->cfg_stream); 101 102 streamer_tree_cache_delete (ob->writer_cache); 103 obstack_free (&ob->obstack, NULL); 104 105 free (ob); 106 } 107 108 109 /* Look up NODE in the type table and write the index for it to OB. */ 110 111 static void 112 output_type_ref (struct output_block *ob, tree node) 113 { 114 streamer_write_record_start (ob, LTO_type_ref); 115 lto_output_type_ref_index (ob->decl_state, ob->main_stream, node); 116 } 117 118 119 /* Return true if tree node T is written to various tables. For these 120 nodes, we sometimes want to write their phyiscal representation 121 (via lto_output_tree), and sometimes we need to emit an index 122 reference into a table (via lto_output_tree_ref). */ 123 124 static bool 125 tree_is_indexable (tree t) 126 { 127 /* Parameters and return values of functions of variably modified types 128 must go to global stream, because they may be used in the type 129 definition. */ 130 if ((TREE_CODE (t) == PARM_DECL || TREE_CODE (t) == RESULT_DECL) 131 && DECL_CONTEXT (t)) 132 return variably_modified_type_p (TREE_TYPE (DECL_CONTEXT (t)), NULL_TREE); 133 /* IMPORTED_DECL is put into BLOCK and thus it never can be shared. */ 134 else if (TREE_CODE (t) == IMPORTED_DECL) 135 return false; 136 else if (((VAR_P (t) && !TREE_STATIC (t)) 137 || TREE_CODE (t) == TYPE_DECL 138 || TREE_CODE (t) == CONST_DECL 139 || TREE_CODE (t) == NAMELIST_DECL) 140 && decl_function_context (t)) 141 return false; 142 else if (TREE_CODE (t) == DEBUG_EXPR_DECL) 143 return false; 144 /* Variably modified types need to be streamed alongside function 145 bodies because they can refer to local entities. Together with 146 them we have to localize their members as well. 147 ??? In theory that includes non-FIELD_DECLs as well. */ 148 else if (TYPE_P (t) 149 && variably_modified_type_p (t, NULL_TREE)) 150 return false; 151 else if (TREE_CODE (t) == FIELD_DECL 152 && variably_modified_type_p (DECL_CONTEXT (t), NULL_TREE)) 153 return false; 154 else 155 return (TYPE_P (t) || DECL_P (t) || TREE_CODE (t) == SSA_NAME); 156 } 157 158 159 /* Output info about new location into bitpack BP. 160 After outputting bitpack, lto_output_location_data has 161 to be done to output actual data. */ 162 163 void 164 lto_output_location (struct output_block *ob, struct bitpack_d *bp, 165 location_t loc) 166 { 167 expanded_location xloc; 168 169 loc = LOCATION_LOCUS (loc); 170 bp_pack_int_in_range (bp, 0, RESERVED_LOCATION_COUNT, 171 loc < RESERVED_LOCATION_COUNT 172 ? loc : RESERVED_LOCATION_COUNT); 173 if (loc < RESERVED_LOCATION_COUNT) 174 return; 175 176 xloc = expand_location (loc); 177 178 bp_pack_value (bp, ob->current_file != xloc.file, 1); 179 bp_pack_value (bp, ob->current_line != xloc.line, 1); 180 bp_pack_value (bp, ob->current_col != xloc.column, 1); 181 182 if (ob->current_file != xloc.file) 183 { 184 bp_pack_string (ob, bp, xloc.file, true); 185 bp_pack_value (bp, xloc.sysp, 1); 186 } 187 ob->current_file = xloc.file; 188 ob->current_sysp = xloc.sysp; 189 190 if (ob->current_line != xloc.line) 191 bp_pack_var_len_unsigned (bp, xloc.line); 192 ob->current_line = xloc.line; 193 194 if (ob->current_col != xloc.column) 195 bp_pack_var_len_unsigned (bp, xloc.column); 196 ob->current_col = xloc.column; 197 } 198 199 200 /* If EXPR is an indexable tree node, output a reference to it to 201 output block OB. Otherwise, output the physical representation of 202 EXPR to OB. */ 203 204 static void 205 lto_output_tree_ref (struct output_block *ob, tree expr) 206 { 207 enum tree_code code; 208 209 if (TYPE_P (expr)) 210 { 211 output_type_ref (ob, expr); 212 return; 213 } 214 215 code = TREE_CODE (expr); 216 switch (code) 217 { 218 case SSA_NAME: 219 streamer_write_record_start (ob, LTO_ssa_name_ref); 220 streamer_write_uhwi (ob, SSA_NAME_VERSION (expr)); 221 break; 222 223 case FIELD_DECL: 224 streamer_write_record_start (ob, LTO_field_decl_ref); 225 lto_output_field_decl_index (ob->decl_state, ob->main_stream, expr); 226 break; 227 228 case FUNCTION_DECL: 229 streamer_write_record_start (ob, LTO_function_decl_ref); 230 lto_output_fn_decl_index (ob->decl_state, ob->main_stream, expr); 231 break; 232 233 case VAR_DECL: 234 case DEBUG_EXPR_DECL: 235 gcc_assert (decl_function_context (expr) == NULL || TREE_STATIC (expr)); 236 /* FALLTHRU */ 237 case PARM_DECL: 238 streamer_write_record_start (ob, LTO_global_decl_ref); 239 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr); 240 break; 241 242 case CONST_DECL: 243 streamer_write_record_start (ob, LTO_const_decl_ref); 244 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr); 245 break; 246 247 case IMPORTED_DECL: 248 gcc_assert (decl_function_context (expr) == NULL); 249 streamer_write_record_start (ob, LTO_imported_decl_ref); 250 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr); 251 break; 252 253 case TYPE_DECL: 254 streamer_write_record_start (ob, LTO_type_decl_ref); 255 lto_output_type_decl_index (ob->decl_state, ob->main_stream, expr); 256 break; 257 258 case NAMELIST_DECL: 259 streamer_write_record_start (ob, LTO_namelist_decl_ref); 260 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr); 261 break; 262 263 case NAMESPACE_DECL: 264 streamer_write_record_start (ob, LTO_namespace_decl_ref); 265 lto_output_namespace_decl_index (ob->decl_state, ob->main_stream, expr); 266 break; 267 268 case LABEL_DECL: 269 streamer_write_record_start (ob, LTO_label_decl_ref); 270 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr); 271 break; 272 273 case RESULT_DECL: 274 streamer_write_record_start (ob, LTO_result_decl_ref); 275 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr); 276 break; 277 278 case TRANSLATION_UNIT_DECL: 279 streamer_write_record_start (ob, LTO_translation_unit_decl_ref); 280 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr); 281 break; 282 283 default: 284 /* No other node is indexable, so it should have been handled by 285 lto_output_tree. */ 286 gcc_unreachable (); 287 } 288 } 289 290 291 /* Return true if EXPR is a tree node that can be written to disk. */ 292 293 static inline bool 294 lto_is_streamable (tree expr) 295 { 296 enum tree_code code = TREE_CODE (expr); 297 298 /* Notice that we reject SSA_NAMEs as well. We only emit the SSA 299 name version in lto_output_tree_ref (see output_ssa_names). */ 300 return !is_lang_specific (expr) 301 && code != SSA_NAME 302 && code != LANG_TYPE 303 && code != MODIFY_EXPR 304 && code != INIT_EXPR 305 && code != TARGET_EXPR 306 && code != BIND_EXPR 307 && code != WITH_CLEANUP_EXPR 308 && code != STATEMENT_LIST 309 && (code == CASE_LABEL_EXPR 310 || code == DECL_EXPR 311 || TREE_CODE_CLASS (code) != tcc_statement); 312 } 313 314 /* Very rough estimate of streaming size of the initializer. If we ignored 315 presence of strings, we could simply just count number of non-indexable 316 tree nodes and number of references to indexable nodes. Strings however 317 may be very large and we do not want to dump them int othe global stream. 318 319 Count the size of initializer until the size in DATA is positive. */ 320 321 static tree 322 subtract_estimated_size (tree *tp, int *ws, void *data) 323 { 324 long *sum = (long *)data; 325 if (tree_is_indexable (*tp)) 326 { 327 /* Indexable tree is one reference to global stream. 328 Guess it may be about 4 bytes. */ 329 *sum -= 4; 330 *ws = 0; 331 } 332 /* String table entry + base of tree node needs to be streamed. */ 333 if (TREE_CODE (*tp) == STRING_CST) 334 *sum -= TREE_STRING_LENGTH (*tp) + 8; 335 else 336 { 337 /* Identifiers are also variable length but should not appear 338 naked in constructor. */ 339 gcc_checking_assert (TREE_CODE (*tp) != IDENTIFIER_NODE); 340 /* We do not really make attempt to work out size of pickled tree, as 341 it is very variable. Make it bigger than the reference. */ 342 *sum -= 16; 343 } 344 if (*sum < 0) 345 return *tp; 346 return NULL_TREE; 347 } 348 349 350 /* For EXPR lookup and return what we want to stream to OB as DECL_INITIAL. */ 351 352 static tree 353 get_symbol_initial_value (lto_symtab_encoder_t encoder, tree expr) 354 { 355 gcc_checking_assert (DECL_P (expr) 356 && TREE_CODE (expr) != FUNCTION_DECL 357 && TREE_CODE (expr) != TRANSLATION_UNIT_DECL); 358 359 /* Handle DECL_INITIAL for symbols. */ 360 tree initial = DECL_INITIAL (expr); 361 if (VAR_P (expr) 362 && (TREE_STATIC (expr) || DECL_EXTERNAL (expr)) 363 && !DECL_IN_CONSTANT_POOL (expr) 364 && initial) 365 { 366 varpool_node *vnode; 367 /* Extra section needs about 30 bytes; do not produce it for simple 368 scalar values. */ 369 if (!(vnode = varpool_node::get (expr)) 370 || !lto_symtab_encoder_encode_initializer_p (encoder, vnode)) 371 initial = error_mark_node; 372 if (initial != error_mark_node) 373 { 374 long max_size = 30; 375 if (walk_tree (&initial, subtract_estimated_size, (void *)&max_size, 376 NULL)) 377 initial = error_mark_node; 378 } 379 } 380 381 return initial; 382 } 383 384 385 /* Write a physical representation of tree node EXPR to output block 386 OB. If REF_P is true, the leaves of EXPR are emitted as references 387 via lto_output_tree_ref. IX is the index into the streamer cache 388 where EXPR is stored. */ 389 390 static void 391 lto_write_tree_1 (struct output_block *ob, tree expr, bool ref_p) 392 { 393 /* Pack all the non-pointer fields in EXPR into a bitpack and write 394 the resulting bitpack. */ 395 streamer_write_tree_bitfields (ob, expr); 396 397 /* Write all the pointer fields in EXPR. */ 398 streamer_write_tree_body (ob, expr, ref_p); 399 400 /* Write any LTO-specific data to OB. */ 401 if (DECL_P (expr) 402 && TREE_CODE (expr) != FUNCTION_DECL 403 && TREE_CODE (expr) != TRANSLATION_UNIT_DECL) 404 { 405 /* Handle DECL_INITIAL for symbols. */ 406 tree initial = get_symbol_initial_value 407 (ob->decl_state->symtab_node_encoder, expr); 408 stream_write_tree (ob, initial, ref_p); 409 } 410 411 /* Stream references to early generated DIEs. Keep in sync with the 412 trees handled in dwarf2out_die_ref_for_decl. */ 413 if ((DECL_P (expr) 414 && TREE_CODE (expr) != FIELD_DECL 415 && TREE_CODE (expr) != DEBUG_EXPR_DECL 416 && TREE_CODE (expr) != TYPE_DECL) 417 || TREE_CODE (expr) == BLOCK) 418 { 419 const char *sym; 420 unsigned HOST_WIDE_INT off; 421 if (debug_info_level > DINFO_LEVEL_NONE 422 && debug_hooks->die_ref_for_decl (expr, &sym, &off)) 423 { 424 streamer_write_string (ob, ob->main_stream, sym, true); 425 streamer_write_uhwi (ob, off); 426 } 427 else 428 streamer_write_string (ob, ob->main_stream, NULL, true); 429 } 430 } 431 432 /* Write a physical representation of tree node EXPR to output block 433 OB. If REF_P is true, the leaves of EXPR are emitted as references 434 via lto_output_tree_ref. IX is the index into the streamer cache 435 where EXPR is stored. */ 436 437 static void 438 lto_write_tree (struct output_block *ob, tree expr, bool ref_p) 439 { 440 if (!lto_is_streamable (expr)) 441 internal_error ("tree code %qs is not supported in LTO streams", 442 get_tree_code_name (TREE_CODE (expr))); 443 444 /* Write the header, containing everything needed to materialize 445 EXPR on the reading side. */ 446 streamer_write_tree_header (ob, expr); 447 448 lto_write_tree_1 (ob, expr, ref_p); 449 450 /* Mark the end of EXPR. */ 451 streamer_write_zero (ob); 452 } 453 454 /* Emit the physical representation of tree node EXPR to output block OB, 455 If THIS_REF_P is true, the leaves of EXPR are emitted as references via 456 lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */ 457 458 static void 459 lto_output_tree_1 (struct output_block *ob, tree expr, hashval_t hash, 460 bool ref_p, bool this_ref_p) 461 { 462 unsigned ix; 463 464 gcc_checking_assert (expr != NULL_TREE 465 && !(this_ref_p && tree_is_indexable (expr))); 466 467 bool exists_p = streamer_tree_cache_insert (ob->writer_cache, 468 expr, hash, &ix); 469 gcc_assert (!exists_p); 470 if (TREE_CODE (expr) == INTEGER_CST 471 && !TREE_OVERFLOW (expr)) 472 { 473 /* Shared INTEGER_CST nodes are special because they need their 474 original type to be materialized by the reader (to implement 475 TYPE_CACHED_VALUES). */ 476 streamer_write_integer_cst (ob, expr, ref_p); 477 } 478 else 479 { 480 /* This is the first time we see EXPR, write its fields 481 to OB. */ 482 lto_write_tree (ob, expr, ref_p); 483 } 484 } 485 486 class DFS 487 { 488 public: 489 DFS (struct output_block *ob, tree expr, bool ref_p, bool this_ref_p, 490 bool single_p); 491 ~DFS (); 492 493 struct scc_entry 494 { 495 tree t; 496 hashval_t hash; 497 }; 498 vec<scc_entry> sccstack; 499 500 private: 501 struct sccs 502 { 503 unsigned int dfsnum; 504 unsigned int low; 505 }; 506 struct worklist 507 { 508 tree expr; 509 sccs *from_state; 510 sccs *cstate; 511 bool ref_p; 512 bool this_ref_p; 513 }; 514 515 static int scc_entry_compare (const void *, const void *); 516 517 void DFS_write_tree_body (struct output_block *ob, 518 tree expr, sccs *expr_state, bool ref_p); 519 520 void DFS_write_tree (struct output_block *ob, sccs *from_state, 521 tree expr, bool ref_p, bool this_ref_p); 522 523 hashval_t 524 hash_scc (struct output_block *ob, unsigned first, unsigned size, 525 bool ref_p, bool this_ref_p); 526 527 hash_map<tree, sccs *> sccstate; 528 vec<worklist> worklist_vec; 529 struct obstack sccstate_obstack; 530 }; 531 532 /* Emit the physical representation of tree node EXPR to output block OB, 533 using depth-first search on the subgraph. If THIS_REF_P is true, the 534 leaves of EXPR are emitted as references via lto_output_tree_ref. 535 REF_P is used for streaming siblings of EXPR. If SINGLE_P is true, 536 this is for a rewalk of a single leaf SCC. */ 537 538 DFS::DFS (struct output_block *ob, tree expr, bool ref_p, bool this_ref_p, 539 bool single_p) 540 { 541 unsigned int next_dfs_num = 1; 542 sccstack.create (0); 543 gcc_obstack_init (&sccstate_obstack); 544 worklist_vec = vNULL; 545 DFS_write_tree (ob, NULL, expr, ref_p, this_ref_p); 546 while (!worklist_vec.is_empty ()) 547 { 548 worklist &w = worklist_vec.last (); 549 expr = w.expr; 550 sccs *from_state = w.from_state; 551 sccs *cstate = w.cstate; 552 ref_p = w.ref_p; 553 this_ref_p = w.this_ref_p; 554 if (cstate == NULL) 555 { 556 sccs **slot = &sccstate.get_or_insert (expr); 557 cstate = *slot; 558 if (cstate) 559 { 560 gcc_checking_assert (from_state); 561 if (cstate->dfsnum < from_state->dfsnum) 562 from_state->low = MIN (cstate->dfsnum, from_state->low); 563 worklist_vec.pop (); 564 continue; 565 } 566 567 scc_entry e = { expr, 0 }; 568 /* Not yet visited. DFS recurse and push it onto the stack. */ 569 *slot = cstate = XOBNEW (&sccstate_obstack, struct sccs); 570 sccstack.safe_push (e); 571 cstate->dfsnum = next_dfs_num++; 572 cstate->low = cstate->dfsnum; 573 w.cstate = cstate; 574 575 if (TREE_CODE (expr) == INTEGER_CST 576 && !TREE_OVERFLOW (expr)) 577 DFS_write_tree (ob, cstate, TREE_TYPE (expr), ref_p, ref_p); 578 else 579 { 580 DFS_write_tree_body (ob, expr, cstate, ref_p); 581 582 /* Walk any LTO-specific edges. */ 583 if (DECL_P (expr) 584 && TREE_CODE (expr) != FUNCTION_DECL 585 && TREE_CODE (expr) != TRANSLATION_UNIT_DECL) 586 { 587 /* Handle DECL_INITIAL for symbols. */ 588 tree initial 589 = get_symbol_initial_value (ob->decl_state->symtab_node_encoder, 590 expr); 591 DFS_write_tree (ob, cstate, initial, ref_p, ref_p); 592 } 593 } 594 continue; 595 } 596 597 /* See if we found an SCC. */ 598 if (cstate->low == cstate->dfsnum) 599 { 600 unsigned first, size; 601 tree x; 602 603 /* If we are re-walking a single leaf SCC just pop it, 604 let earlier worklist item access the sccstack. */ 605 if (single_p) 606 { 607 worklist_vec.pop (); 608 continue; 609 } 610 611 /* Pop the SCC and compute its size. */ 612 first = sccstack.length (); 613 do 614 { 615 x = sccstack[--first].t; 616 } 617 while (x != expr); 618 size = sccstack.length () - first; 619 620 /* No need to compute hashes for LTRANS units, we don't perform 621 any merging there. */ 622 hashval_t scc_hash = 0; 623 unsigned scc_entry_len = 0; 624 if (!flag_wpa) 625 { 626 scc_hash = hash_scc (ob, first, size, ref_p, this_ref_p); 627 628 /* Put the entries with the least number of collisions first. */ 629 unsigned entry_start = 0; 630 scc_entry_len = size + 1; 631 for (unsigned i = 0; i < size;) 632 { 633 unsigned from = i; 634 for (i = i + 1; i < size 635 && (sccstack[first + i].hash 636 == sccstack[first + from].hash); ++i) 637 ; 638 if (i - from < scc_entry_len) 639 { 640 scc_entry_len = i - from; 641 entry_start = from; 642 } 643 } 644 for (unsigned i = 0; i < scc_entry_len; ++i) 645 std::swap (sccstack[first + i], 646 sccstack[first + entry_start + i]); 647 648 /* We already sorted SCC deterministically in hash_scc. */ 649 650 /* Check that we have only one SCC. 651 Naturally we may have conflicts if hash function is not 652 strong enough. Lets see how far this gets. */ 653 gcc_checking_assert (scc_entry_len == 1); 654 } 655 656 /* Write LTO_tree_scc. */ 657 streamer_write_record_start (ob, LTO_tree_scc); 658 streamer_write_uhwi (ob, size); 659 streamer_write_uhwi (ob, scc_hash); 660 661 /* Write size-1 SCCs without wrapping them inside SCC bundles. 662 All INTEGER_CSTs need to be handled this way as we need 663 their type to materialize them. Also builtins are handled 664 this way. 665 ??? We still wrap these in LTO_tree_scc so at the 666 input side we can properly identify the tree we want 667 to ultimatively return. */ 668 if (size == 1) 669 lto_output_tree_1 (ob, expr, scc_hash, ref_p, this_ref_p); 670 else 671 { 672 /* Write the size of the SCC entry candidates. */ 673 streamer_write_uhwi (ob, scc_entry_len); 674 675 /* Write all headers and populate the streamer cache. */ 676 for (unsigned i = 0; i < size; ++i) 677 { 678 hashval_t hash = sccstack[first+i].hash; 679 tree t = sccstack[first+i].t; 680 bool exists_p = streamer_tree_cache_insert (ob->writer_cache, 681 t, hash, NULL); 682 gcc_assert (!exists_p); 683 684 if (!lto_is_streamable (t)) 685 internal_error ("tree code %qs is not supported " 686 "in LTO streams", 687 get_tree_code_name (TREE_CODE (t))); 688 689 /* Write the header, containing everything needed to 690 materialize EXPR on the reading side. */ 691 streamer_write_tree_header (ob, t); 692 } 693 694 /* Write the bitpacks and tree references. */ 695 for (unsigned i = 0; i < size; ++i) 696 { 697 lto_write_tree_1 (ob, sccstack[first+i].t, ref_p); 698 699 /* Mark the end of the tree. */ 700 streamer_write_zero (ob); 701 } 702 } 703 704 /* Finally truncate the vector. */ 705 sccstack.truncate (first); 706 707 if (from_state) 708 from_state->low = MIN (from_state->low, cstate->low); 709 worklist_vec.pop (); 710 continue; 711 } 712 713 gcc_checking_assert (from_state); 714 from_state->low = MIN (from_state->low, cstate->low); 715 if (cstate->dfsnum < from_state->dfsnum) 716 from_state->low = MIN (cstate->dfsnum, from_state->low); 717 worklist_vec.pop (); 718 } 719 worklist_vec.release (); 720 } 721 722 DFS::~DFS () 723 { 724 sccstack.release (); 725 obstack_free (&sccstate_obstack, NULL); 726 } 727 728 /* Handle the tree EXPR in the DFS walk with SCC state EXPR_STATE and 729 DFS recurse for all tree edges originating from it. */ 730 731 void 732 DFS::DFS_write_tree_body (struct output_block *ob, 733 tree expr, sccs *expr_state, bool ref_p) 734 { 735 #define DFS_follow_tree_edge(DEST) \ 736 DFS_write_tree (ob, expr_state, DEST, ref_p, ref_p) 737 738 enum tree_code code; 739 740 code = TREE_CODE (expr); 741 742 if (CODE_CONTAINS_STRUCT (code, TS_TYPED)) 743 { 744 if (TREE_CODE (expr) != IDENTIFIER_NODE) 745 DFS_follow_tree_edge (TREE_TYPE (expr)); 746 } 747 748 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR)) 749 { 750 unsigned int count = vector_cst_encoded_nelts (expr); 751 for (unsigned int i = 0; i < count; ++i) 752 DFS_follow_tree_edge (VECTOR_CST_ENCODED_ELT (expr, i)); 753 } 754 755 if (CODE_CONTAINS_STRUCT (code, TS_POLY_INT_CST)) 756 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i) 757 DFS_follow_tree_edge (POLY_INT_CST_COEFF (expr, i)); 758 759 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX)) 760 { 761 DFS_follow_tree_edge (TREE_REALPART (expr)); 762 DFS_follow_tree_edge (TREE_IMAGPART (expr)); 763 } 764 765 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL)) 766 { 767 /* Drop names that were created for anonymous entities. */ 768 if (DECL_NAME (expr) 769 && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE 770 && anon_aggrname_p (DECL_NAME (expr))) 771 ; 772 else 773 DFS_follow_tree_edge (DECL_NAME (expr)); 774 if (TREE_CODE (expr) != TRANSLATION_UNIT_DECL 775 && ! DECL_CONTEXT (expr)) 776 DFS_follow_tree_edge ((*all_translation_units)[0]); 777 else 778 DFS_follow_tree_edge (DECL_CONTEXT (expr)); 779 } 780 781 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) 782 { 783 DFS_follow_tree_edge (DECL_SIZE (expr)); 784 DFS_follow_tree_edge (DECL_SIZE_UNIT (expr)); 785 786 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs 787 special handling in LTO, it must be handled by streamer hooks. */ 788 789 DFS_follow_tree_edge (DECL_ATTRIBUTES (expr)); 790 791 /* Do not follow DECL_ABSTRACT_ORIGIN. We cannot handle debug information 792 for early inlining so drop it on the floor instead of ICEing in 793 dwarf2out.c. 794 We however use DECL_ABSTRACT_ORIGIN == error_mark_node to mark 795 declarations which should be eliminated by decl merging. Be sure none 796 leaks to this point. */ 797 gcc_assert (DECL_ABSTRACT_ORIGIN (expr) != error_mark_node); 798 DFS_follow_tree_edge (DECL_ABSTRACT_ORIGIN (expr)); 799 800 if ((VAR_P (expr) 801 || TREE_CODE (expr) == PARM_DECL) 802 && DECL_HAS_VALUE_EXPR_P (expr)) 803 DFS_follow_tree_edge (DECL_VALUE_EXPR (expr)); 804 if (VAR_P (expr) 805 && DECL_HAS_DEBUG_EXPR_P (expr)) 806 DFS_follow_tree_edge (DECL_DEBUG_EXPR (expr)); 807 } 808 809 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON)) 810 { 811 if (TREE_CODE (expr) == TYPE_DECL) 812 DFS_follow_tree_edge (DECL_ORIGINAL_TYPE (expr)); 813 } 814 815 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)) 816 { 817 /* Make sure we don't inadvertently set the assembler name. */ 818 if (DECL_ASSEMBLER_NAME_SET_P (expr)) 819 DFS_follow_tree_edge (DECL_ASSEMBLER_NAME (expr)); 820 } 821 822 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL)) 823 { 824 DFS_follow_tree_edge (DECL_FIELD_OFFSET (expr)); 825 DFS_follow_tree_edge (DECL_BIT_FIELD_TYPE (expr)); 826 DFS_follow_tree_edge (DECL_BIT_FIELD_REPRESENTATIVE (expr)); 827 DFS_follow_tree_edge (DECL_FIELD_BIT_OFFSET (expr)); 828 DFS_follow_tree_edge (DECL_FCONTEXT (expr)); 829 } 830 831 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL)) 832 { 833 DFS_follow_tree_edge (DECL_VINDEX (expr)); 834 DFS_follow_tree_edge (DECL_FUNCTION_PERSONALITY (expr)); 835 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_TARGET (expr)); 836 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr)); 837 } 838 839 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON)) 840 { 841 DFS_follow_tree_edge (TYPE_SIZE (expr)); 842 DFS_follow_tree_edge (TYPE_SIZE_UNIT (expr)); 843 DFS_follow_tree_edge (TYPE_ATTRIBUTES (expr)); 844 DFS_follow_tree_edge (TYPE_NAME (expr)); 845 /* Do not follow TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be 846 reconstructed during fixup. */ 847 /* Do not follow TYPE_NEXT_VARIANT, we reconstruct the variant lists 848 during fixup. */ 849 DFS_follow_tree_edge (TYPE_MAIN_VARIANT (expr)); 850 DFS_follow_tree_edge (TYPE_CONTEXT (expr)); 851 /* TYPE_CANONICAL is re-computed during type merging, so no need 852 to follow it here. */ 853 DFS_follow_tree_edge (TYPE_STUB_DECL (expr)); 854 } 855 856 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON)) 857 { 858 if (TREE_CODE (expr) == ENUMERAL_TYPE) 859 DFS_follow_tree_edge (TYPE_VALUES (expr)); 860 else if (TREE_CODE (expr) == ARRAY_TYPE) 861 DFS_follow_tree_edge (TYPE_DOMAIN (expr)); 862 else if (RECORD_OR_UNION_TYPE_P (expr)) 863 for (tree t = TYPE_FIELDS (expr); t; t = TREE_CHAIN (t)) 864 DFS_follow_tree_edge (t); 865 else if (TREE_CODE (expr) == FUNCTION_TYPE 866 || TREE_CODE (expr) == METHOD_TYPE) 867 DFS_follow_tree_edge (TYPE_ARG_TYPES (expr)); 868 869 if (!POINTER_TYPE_P (expr)) 870 DFS_follow_tree_edge (TYPE_MIN_VALUE_RAW (expr)); 871 DFS_follow_tree_edge (TYPE_MAX_VALUE_RAW (expr)); 872 } 873 874 if (CODE_CONTAINS_STRUCT (code, TS_LIST)) 875 { 876 DFS_follow_tree_edge (TREE_PURPOSE (expr)); 877 DFS_follow_tree_edge (TREE_VALUE (expr)); 878 DFS_follow_tree_edge (TREE_CHAIN (expr)); 879 } 880 881 if (CODE_CONTAINS_STRUCT (code, TS_VEC)) 882 { 883 for (int i = 0; i < TREE_VEC_LENGTH (expr); i++) 884 DFS_follow_tree_edge (TREE_VEC_ELT (expr, i)); 885 } 886 887 if (CODE_CONTAINS_STRUCT (code, TS_EXP)) 888 { 889 for (int i = 0; i < TREE_OPERAND_LENGTH (expr); i++) 890 DFS_follow_tree_edge (TREE_OPERAND (expr, i)); 891 DFS_follow_tree_edge (TREE_BLOCK (expr)); 892 } 893 894 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK)) 895 { 896 for (tree t = BLOCK_VARS (expr); t; t = TREE_CHAIN (t)) 897 if (VAR_OR_FUNCTION_DECL_P (t) 898 && DECL_EXTERNAL (t)) 899 /* We have to stream externals in the block chain as 900 non-references. See also 901 tree-streamer-out.c:streamer_write_chain. */ 902 DFS_write_tree (ob, expr_state, t, ref_p, false); 903 else 904 DFS_follow_tree_edge (t); 905 906 DFS_follow_tree_edge (BLOCK_SUPERCONTEXT (expr)); 907 908 /* Follow BLOCK_ABSTRACT_ORIGIN for the limited cases we can 909 handle - those that represent inlined function scopes. 910 For the drop rest them on the floor instead of ICEing 911 in dwarf2out.c, but keep the notion of whether the block 912 is an inlined block by refering to itself for the sake of 913 tree_nonartificial_location. */ 914 if (inlined_function_outer_scope_p (expr)) 915 { 916 tree ultimate_origin = block_ultimate_origin (expr); 917 DFS_follow_tree_edge (ultimate_origin); 918 } 919 else if (BLOCK_ABSTRACT_ORIGIN (expr)) 920 DFS_follow_tree_edge (expr); 921 /* Do not follow BLOCK_NONLOCALIZED_VARS. We cannot handle debug 922 information for early inlined BLOCKs so drop it on the floor instead 923 of ICEing in dwarf2out.c. */ 924 925 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO 926 streaming time. */ 927 928 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this 929 list is re-constructed from BLOCK_SUPERCONTEXT. */ 930 } 931 932 if (CODE_CONTAINS_STRUCT (code, TS_BINFO)) 933 { 934 unsigned i; 935 tree t; 936 937 /* Note that the number of BINFO slots has already been emitted in 938 EXPR's header (see streamer_write_tree_header) because this length 939 is needed to build the empty BINFO node on the reader side. */ 940 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t) 941 DFS_follow_tree_edge (t); 942 DFS_follow_tree_edge (BINFO_OFFSET (expr)); 943 DFS_follow_tree_edge (BINFO_VTABLE (expr)); 944 DFS_follow_tree_edge (BINFO_VPTR_FIELD (expr)); 945 946 /* The number of BINFO_BASE_ACCESSES has already been emitted in 947 EXPR's bitfield section. */ 948 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr), i, t) 949 DFS_follow_tree_edge (t); 950 951 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX 952 and BINFO_VPTR_INDEX; these are used by C++ FE only. */ 953 } 954 955 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR)) 956 { 957 unsigned i; 958 tree index, value; 959 960 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value) 961 { 962 DFS_follow_tree_edge (index); 963 DFS_follow_tree_edge (value); 964 } 965 } 966 967 if (code == OMP_CLAUSE) 968 { 969 int i; 970 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++) 971 DFS_follow_tree_edge (OMP_CLAUSE_OPERAND (expr, i)); 972 DFS_follow_tree_edge (OMP_CLAUSE_CHAIN (expr)); 973 } 974 975 #undef DFS_follow_tree_edge 976 } 977 978 /* Return a hash value for the tree T. 979 CACHE holds hash values of trees outside current SCC. MAP, if non-NULL, 980 may hold hash values if trees inside current SCC. */ 981 982 static hashval_t 983 hash_tree (struct streamer_tree_cache_d *cache, hash_map<tree, hashval_t> *map, tree t) 984 { 985 inchash::hash hstate; 986 987 #define visit(SIBLING) \ 988 do { \ 989 unsigned ix; \ 990 if (!SIBLING) \ 991 hstate.add_int (0); \ 992 else if (streamer_tree_cache_lookup (cache, SIBLING, &ix)) \ 993 hstate.add_int (streamer_tree_cache_get_hash (cache, ix)); \ 994 else if (map) \ 995 hstate.add_int (*map->get (SIBLING)); \ 996 else \ 997 hstate.add_int (1); \ 998 } while (0) 999 1000 /* Hash TS_BASE. */ 1001 enum tree_code code = TREE_CODE (t); 1002 hstate.add_int (code); 1003 if (!TYPE_P (t)) 1004 { 1005 hstate.add_flag (TREE_SIDE_EFFECTS (t)); 1006 hstate.add_flag (TREE_CONSTANT (t)); 1007 hstate.add_flag (TREE_READONLY (t)); 1008 hstate.add_flag (TREE_PUBLIC (t)); 1009 } 1010 hstate.add_flag (TREE_ADDRESSABLE (t)); 1011 hstate.add_flag (TREE_THIS_VOLATILE (t)); 1012 if (DECL_P (t)) 1013 hstate.add_flag (DECL_UNSIGNED (t)); 1014 else if (TYPE_P (t)) 1015 hstate.add_flag (TYPE_UNSIGNED (t)); 1016 if (TYPE_P (t)) 1017 hstate.add_flag (TYPE_ARTIFICIAL (t)); 1018 else 1019 hstate.add_flag (TREE_NO_WARNING (t)); 1020 hstate.add_flag (TREE_NOTHROW (t)); 1021 hstate.add_flag (TREE_STATIC (t)); 1022 hstate.add_flag (TREE_PROTECTED (t)); 1023 hstate.add_flag (TREE_DEPRECATED (t)); 1024 if (code != TREE_BINFO) 1025 hstate.add_flag (TREE_PRIVATE (t)); 1026 if (TYPE_P (t)) 1027 { 1028 hstate.add_flag (AGGREGATE_TYPE_P (t) 1029 ? TYPE_REVERSE_STORAGE_ORDER (t) : TYPE_SATURATING (t)); 1030 hstate.add_flag (TYPE_ADDR_SPACE (t)); 1031 } 1032 else if (code == SSA_NAME) 1033 hstate.add_flag (SSA_NAME_IS_DEFAULT_DEF (t)); 1034 hstate.commit_flag (); 1035 1036 if (CODE_CONTAINS_STRUCT (code, TS_INT_CST)) 1037 hstate.add_wide_int (wi::to_widest (t)); 1038 1039 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST)) 1040 { 1041 REAL_VALUE_TYPE r = TREE_REAL_CST (t); 1042 hstate.add_flag (r.cl); 1043 hstate.add_flag (r.sign); 1044 hstate.add_flag (r.signalling); 1045 hstate.add_flag (r.canonical); 1046 hstate.commit_flag (); 1047 hstate.add_int (r.uexp); 1048 hstate.add (r.sig, sizeof (r.sig)); 1049 } 1050 1051 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST)) 1052 { 1053 FIXED_VALUE_TYPE f = TREE_FIXED_CST (t); 1054 hstate.add_int (f.mode); 1055 hstate.add_int (f.data.low); 1056 hstate.add_int (f.data.high); 1057 } 1058 1059 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) 1060 { 1061 hstate.add_hwi (DECL_MODE (t)); 1062 hstate.add_flag (DECL_NONLOCAL (t)); 1063 hstate.add_flag (DECL_VIRTUAL_P (t)); 1064 hstate.add_flag (DECL_IGNORED_P (t)); 1065 hstate.add_flag (DECL_ABSTRACT_P (t)); 1066 hstate.add_flag (DECL_ARTIFICIAL (t)); 1067 hstate.add_flag (DECL_USER_ALIGN (t)); 1068 hstate.add_flag (DECL_PRESERVE_P (t)); 1069 hstate.add_flag (DECL_EXTERNAL (t)); 1070 hstate.add_flag (DECL_GIMPLE_REG_P (t)); 1071 hstate.commit_flag (); 1072 hstate.add_int (DECL_ALIGN (t)); 1073 if (code == LABEL_DECL) 1074 { 1075 hstate.add_int (EH_LANDING_PAD_NR (t)); 1076 hstate.add_int (LABEL_DECL_UID (t)); 1077 } 1078 else if (code == FIELD_DECL) 1079 { 1080 hstate.add_flag (DECL_PACKED (t)); 1081 hstate.add_flag (DECL_NONADDRESSABLE_P (t)); 1082 hstate.add_flag (DECL_PADDING_P (t)); 1083 hstate.add_int (DECL_OFFSET_ALIGN (t)); 1084 } 1085 else if (code == VAR_DECL) 1086 { 1087 hstate.add_flag (DECL_HAS_DEBUG_EXPR_P (t)); 1088 hstate.add_flag (DECL_NONLOCAL_FRAME (t)); 1089 } 1090 if (code == RESULT_DECL 1091 || code == PARM_DECL 1092 || code == VAR_DECL) 1093 { 1094 hstate.add_flag (DECL_BY_REFERENCE (t)); 1095 if (code == VAR_DECL 1096 || code == PARM_DECL) 1097 hstate.add_flag (DECL_HAS_VALUE_EXPR_P (t)); 1098 } 1099 hstate.commit_flag (); 1100 } 1101 1102 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL)) 1103 hstate.add_int (DECL_REGISTER (t)); 1104 1105 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)) 1106 { 1107 hstate.add_flag (DECL_COMMON (t)); 1108 hstate.add_flag (DECL_DLLIMPORT_P (t)); 1109 hstate.add_flag (DECL_WEAK (t)); 1110 hstate.add_flag (DECL_SEEN_IN_BIND_EXPR_P (t)); 1111 hstate.add_flag (DECL_COMDAT (t)); 1112 hstate.add_flag (DECL_VISIBILITY_SPECIFIED (t)); 1113 hstate.add_int (DECL_VISIBILITY (t)); 1114 if (code == VAR_DECL) 1115 { 1116 /* DECL_IN_TEXT_SECTION is set during final asm output only. */ 1117 hstate.add_flag (DECL_HARD_REGISTER (t)); 1118 hstate.add_flag (DECL_IN_CONSTANT_POOL (t)); 1119 } 1120 if (TREE_CODE (t) == FUNCTION_DECL) 1121 { 1122 hstate.add_flag (DECL_FINAL_P (t)); 1123 hstate.add_flag (DECL_CXX_CONSTRUCTOR_P (t)); 1124 hstate.add_flag (DECL_CXX_DESTRUCTOR_P (t)); 1125 } 1126 hstate.commit_flag (); 1127 } 1128 1129 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL)) 1130 { 1131 hstate.add_int (DECL_BUILT_IN_CLASS (t)); 1132 hstate.add_flag (DECL_STATIC_CONSTRUCTOR (t)); 1133 hstate.add_flag (DECL_STATIC_DESTRUCTOR (t)); 1134 hstate.add_flag (DECL_UNINLINABLE (t)); 1135 hstate.add_flag (DECL_POSSIBLY_INLINED (t)); 1136 hstate.add_flag (DECL_IS_NOVOPS (t)); 1137 hstate.add_flag (DECL_IS_RETURNS_TWICE (t)); 1138 hstate.add_flag (DECL_IS_MALLOC (t)); 1139 hstate.add_flag (DECL_IS_OPERATOR_NEW (t)); 1140 hstate.add_flag (DECL_DECLARED_INLINE_P (t)); 1141 hstate.add_flag (DECL_STATIC_CHAIN (t)); 1142 hstate.add_flag (DECL_NO_INLINE_WARNING_P (t)); 1143 hstate.add_flag (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (t)); 1144 hstate.add_flag (DECL_NO_LIMIT_STACK (t)); 1145 hstate.add_flag (DECL_DISREGARD_INLINE_LIMITS (t)); 1146 hstate.add_flag (DECL_PURE_P (t)); 1147 hstate.add_flag (DECL_LOOPING_CONST_OR_PURE_P (t)); 1148 hstate.commit_flag (); 1149 if (DECL_BUILT_IN_CLASS (t) != NOT_BUILT_IN) 1150 hstate.add_int (DECL_FUNCTION_CODE (t)); 1151 } 1152 1153 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON)) 1154 { 1155 hstate.add_hwi (TYPE_MODE (t)); 1156 hstate.add_flag (TYPE_STRING_FLAG (t)); 1157 /* TYPE_NO_FORCE_BLK is private to stor-layout and need 1158 no streaming. */ 1159 hstate.add_flag (TYPE_NEEDS_CONSTRUCTING (t)); 1160 hstate.add_flag (TYPE_PACKED (t)); 1161 hstate.add_flag (TYPE_RESTRICT (t)); 1162 hstate.add_flag (TYPE_USER_ALIGN (t)); 1163 hstate.add_flag (TYPE_READONLY (t)); 1164 if (RECORD_OR_UNION_TYPE_P (t)) 1165 { 1166 hstate.add_flag (TYPE_TRANSPARENT_AGGR (t)); 1167 hstate.add_flag (TYPE_FINAL_P (t)); 1168 } 1169 else if (code == ARRAY_TYPE) 1170 hstate.add_flag (TYPE_NONALIASED_COMPONENT (t)); 1171 if (AGGREGATE_TYPE_P (t)) 1172 hstate.add_flag (TYPE_TYPELESS_STORAGE (t)); 1173 hstate.commit_flag (); 1174 hstate.add_int (TYPE_PRECISION (t)); 1175 hstate.add_int (TYPE_ALIGN (t)); 1176 hstate.add_int (TYPE_EMPTY_P (t)); 1177 } 1178 1179 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL)) 1180 hstate.add (TRANSLATION_UNIT_LANGUAGE (t), 1181 strlen (TRANSLATION_UNIT_LANGUAGE (t))); 1182 1183 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION) 1184 /* We don't stream these when passing things to a different target. */ 1185 && !lto_stream_offload_p) 1186 hstate.add_hwi (cl_target_option_hash (TREE_TARGET_OPTION (t))); 1187 1188 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION)) 1189 hstate.add_hwi (cl_optimization_hash (TREE_OPTIMIZATION (t))); 1190 1191 if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER)) 1192 hstate.merge_hash (IDENTIFIER_HASH_VALUE (t)); 1193 1194 if (CODE_CONTAINS_STRUCT (code, TS_STRING)) 1195 hstate.add (TREE_STRING_POINTER (t), TREE_STRING_LENGTH (t)); 1196 1197 if (CODE_CONTAINS_STRUCT (code, TS_TYPED)) 1198 { 1199 if (code != IDENTIFIER_NODE) 1200 visit (TREE_TYPE (t)); 1201 } 1202 1203 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR)) 1204 { 1205 unsigned int count = vector_cst_encoded_nelts (t); 1206 for (unsigned int i = 0; i < count; ++i) 1207 visit (VECTOR_CST_ENCODED_ELT (t, i)); 1208 } 1209 1210 if (CODE_CONTAINS_STRUCT (code, TS_POLY_INT_CST)) 1211 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i) 1212 visit (POLY_INT_CST_COEFF (t, i)); 1213 1214 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX)) 1215 { 1216 visit (TREE_REALPART (t)); 1217 visit (TREE_IMAGPART (t)); 1218 } 1219 1220 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL)) 1221 { 1222 /* Drop names that were created for anonymous entities. */ 1223 if (DECL_NAME (t) 1224 && TREE_CODE (DECL_NAME (t)) == IDENTIFIER_NODE 1225 && anon_aggrname_p (DECL_NAME (t))) 1226 ; 1227 else 1228 visit (DECL_NAME (t)); 1229 if (DECL_FILE_SCOPE_P (t)) 1230 ; 1231 else 1232 visit (DECL_CONTEXT (t)); 1233 } 1234 1235 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) 1236 { 1237 visit (DECL_SIZE (t)); 1238 visit (DECL_SIZE_UNIT (t)); 1239 visit (DECL_ATTRIBUTES (t)); 1240 if ((code == VAR_DECL 1241 || code == PARM_DECL) 1242 && DECL_HAS_VALUE_EXPR_P (t)) 1243 visit (DECL_VALUE_EXPR (t)); 1244 if (code == VAR_DECL 1245 && DECL_HAS_DEBUG_EXPR_P (t)) 1246 visit (DECL_DEBUG_EXPR (t)); 1247 /* ??? Hash DECL_INITIAL as streamed. Needs the output-block to 1248 be able to call get_symbol_initial_value. */ 1249 } 1250 1251 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON)) 1252 { 1253 if (code == TYPE_DECL) 1254 visit (DECL_ORIGINAL_TYPE (t)); 1255 } 1256 1257 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)) 1258 { 1259 if (DECL_ASSEMBLER_NAME_SET_P (t)) 1260 visit (DECL_ASSEMBLER_NAME (t)); 1261 } 1262 1263 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL)) 1264 { 1265 visit (DECL_FIELD_OFFSET (t)); 1266 visit (DECL_BIT_FIELD_TYPE (t)); 1267 visit (DECL_BIT_FIELD_REPRESENTATIVE (t)); 1268 visit (DECL_FIELD_BIT_OFFSET (t)); 1269 visit (DECL_FCONTEXT (t)); 1270 } 1271 1272 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL)) 1273 { 1274 visit (DECL_VINDEX (t)); 1275 visit (DECL_FUNCTION_PERSONALITY (t)); 1276 visit (DECL_FUNCTION_SPECIFIC_TARGET (t)); 1277 visit (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t)); 1278 } 1279 1280 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON)) 1281 { 1282 visit (TYPE_SIZE (t)); 1283 visit (TYPE_SIZE_UNIT (t)); 1284 visit (TYPE_ATTRIBUTES (t)); 1285 visit (TYPE_NAME (t)); 1286 visit (TYPE_MAIN_VARIANT (t)); 1287 if (TYPE_FILE_SCOPE_P (t)) 1288 ; 1289 else 1290 visit (TYPE_CONTEXT (t)); 1291 visit (TYPE_STUB_DECL (t)); 1292 } 1293 1294 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON)) 1295 { 1296 if (code == ENUMERAL_TYPE) 1297 visit (TYPE_VALUES (t)); 1298 else if (code == ARRAY_TYPE) 1299 visit (TYPE_DOMAIN (t)); 1300 else if (RECORD_OR_UNION_TYPE_P (t)) 1301 for (tree f = TYPE_FIELDS (t); f; f = TREE_CHAIN (f)) 1302 visit (f); 1303 else if (code == FUNCTION_TYPE 1304 || code == METHOD_TYPE) 1305 visit (TYPE_ARG_TYPES (t)); 1306 if (!POINTER_TYPE_P (t)) 1307 visit (TYPE_MIN_VALUE_RAW (t)); 1308 visit (TYPE_MAX_VALUE_RAW (t)); 1309 } 1310 1311 if (CODE_CONTAINS_STRUCT (code, TS_LIST)) 1312 { 1313 visit (TREE_PURPOSE (t)); 1314 visit (TREE_VALUE (t)); 1315 visit (TREE_CHAIN (t)); 1316 } 1317 1318 if (CODE_CONTAINS_STRUCT (code, TS_VEC)) 1319 for (int i = 0; i < TREE_VEC_LENGTH (t); ++i) 1320 visit (TREE_VEC_ELT (t, i)); 1321 1322 if (CODE_CONTAINS_STRUCT (code, TS_EXP)) 1323 { 1324 hstate.add_hwi (TREE_OPERAND_LENGTH (t)); 1325 for (int i = 0; i < TREE_OPERAND_LENGTH (t); ++i) 1326 visit (TREE_OPERAND (t, i)); 1327 } 1328 1329 if (CODE_CONTAINS_STRUCT (code, TS_BINFO)) 1330 { 1331 unsigned i; 1332 tree b; 1333 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t), i, b) 1334 visit (b); 1335 visit (BINFO_OFFSET (t)); 1336 visit (BINFO_VTABLE (t)); 1337 visit (BINFO_VPTR_FIELD (t)); 1338 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (t), i, b) 1339 visit (b); 1340 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX 1341 and BINFO_VPTR_INDEX; these are used by C++ FE only. */ 1342 } 1343 1344 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR)) 1345 { 1346 unsigned i; 1347 tree index, value; 1348 hstate.add_hwi (CONSTRUCTOR_NELTS (t)); 1349 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), i, index, value) 1350 { 1351 visit (index); 1352 visit (value); 1353 } 1354 } 1355 1356 if (code == OMP_CLAUSE) 1357 { 1358 int i; 1359 HOST_WIDE_INT val; 1360 1361 hstate.add_hwi (OMP_CLAUSE_CODE (t)); 1362 switch (OMP_CLAUSE_CODE (t)) 1363 { 1364 case OMP_CLAUSE_DEFAULT: 1365 val = OMP_CLAUSE_DEFAULT_KIND (t); 1366 break; 1367 case OMP_CLAUSE_SCHEDULE: 1368 val = OMP_CLAUSE_SCHEDULE_KIND (t); 1369 break; 1370 case OMP_CLAUSE_DEPEND: 1371 val = OMP_CLAUSE_DEPEND_KIND (t); 1372 break; 1373 case OMP_CLAUSE_MAP: 1374 val = OMP_CLAUSE_MAP_KIND (t); 1375 break; 1376 case OMP_CLAUSE_PROC_BIND: 1377 val = OMP_CLAUSE_PROC_BIND_KIND (t); 1378 break; 1379 case OMP_CLAUSE_REDUCTION: 1380 val = OMP_CLAUSE_REDUCTION_CODE (t); 1381 break; 1382 default: 1383 val = 0; 1384 break; 1385 } 1386 hstate.add_hwi (val); 1387 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++) 1388 visit (OMP_CLAUSE_OPERAND (t, i)); 1389 visit (OMP_CLAUSE_CHAIN (t)); 1390 } 1391 1392 return hstate.end (); 1393 1394 #undef visit 1395 } 1396 1397 /* Compare two SCC entries by their hash value for qsorting them. */ 1398 1399 int 1400 DFS::scc_entry_compare (const void *p1_, const void *p2_) 1401 { 1402 const scc_entry *p1 = (const scc_entry *) p1_; 1403 const scc_entry *p2 = (const scc_entry *) p2_; 1404 if (p1->hash < p2->hash) 1405 return -1; 1406 else if (p1->hash > p2->hash) 1407 return 1; 1408 return 0; 1409 } 1410 1411 /* Return a hash value for the SCC on the SCC stack from FIRST with SIZE. 1412 THIS_REF_P and REF_P are as passed to lto_output_tree for FIRST. */ 1413 1414 hashval_t 1415 DFS::hash_scc (struct output_block *ob, unsigned first, unsigned size, 1416 bool ref_p, bool this_ref_p) 1417 { 1418 unsigned int last_classes = 0, iterations = 0; 1419 1420 /* Compute hash values for the SCC members. */ 1421 for (unsigned i = 0; i < size; ++i) 1422 sccstack[first+i].hash 1423 = hash_tree (ob->writer_cache, NULL, sccstack[first+i].t); 1424 1425 if (size == 1) 1426 return sccstack[first].hash; 1427 1428 /* We aim to get unique hash for every tree within SCC and compute hash value 1429 of the whole SCC by combining all values together in a stable (entry-point 1430 independent) order. This guarantees that the same SCC regions within 1431 different translation units will get the same hash values and therefore 1432 will be merged at WPA time. 1433 1434 Often the hashes are already unique. In that case we compute the SCC hash 1435 by combining individual hash values in an increasing order. 1436 1437 If there are duplicates, we seek at least one tree with unique hash (and 1438 pick one with minimal hash and this property). Then we obtain a stable 1439 order by DFS walk starting from this unique tree and then use the index 1440 within this order to make individual hash values unique. 1441 1442 If there is no tree with unique hash, we iteratively propagate the hash 1443 values across the internal edges of SCC. This usually quickly leads 1444 to unique hashes. Consider, for example, an SCC containing two pointers 1445 that are identical except for the types they point to and assume that 1446 these types are also part of the SCC. The propagation will add the 1447 points-to type information into their hash values. */ 1448 do 1449 { 1450 /* Sort the SCC so we can easily check for uniqueness. */ 1451 qsort (&sccstack[first], size, sizeof (scc_entry), scc_entry_compare); 1452 1453 unsigned int classes = 1; 1454 int firstunique = -1; 1455 1456 /* Find the tree with lowest unique hash (if it exists) and compute 1457 the number of equivalence classes. */ 1458 if (sccstack[first].hash != sccstack[first+1].hash) 1459 firstunique = 0; 1460 for (unsigned i = 1; i < size; ++i) 1461 if (sccstack[first+i-1].hash != sccstack[first+i].hash) 1462 { 1463 classes++; 1464 if (firstunique == -1 1465 && (i == size - 1 1466 || sccstack[first+i+1].hash != sccstack[first+i].hash)) 1467 firstunique = i; 1468 } 1469 1470 /* If we found a tree with unique hash, stop the iteration. */ 1471 if (firstunique != -1 1472 /* Also terminate if we run out of iterations or if the number of 1473 equivalence classes is no longer increasing. 1474 For example a cyclic list of trees that are all equivalent will 1475 never have unique entry point; we however do not build such SCCs 1476 in our IL. */ 1477 || classes <= last_classes || iterations > 16) 1478 { 1479 hashval_t scc_hash; 1480 1481 /* If some hashes are not unique (CLASSES != SIZE), use the DFS walk 1482 starting from FIRSTUNIQUE to obtain a stable order. */ 1483 if (classes != size && firstunique != -1) 1484 { 1485 hash_map <tree, hashval_t> map(size*2); 1486 1487 /* Store hash values into a map, so we can associate them with 1488 the reordered SCC. */ 1489 for (unsigned i = 0; i < size; ++i) 1490 map.put (sccstack[first+i].t, sccstack[first+i].hash); 1491 1492 DFS again (ob, sccstack[first+firstunique].t, ref_p, this_ref_p, 1493 true); 1494 gcc_assert (again.sccstack.length () == size); 1495 1496 memcpy (sccstack.address () + first, 1497 again.sccstack.address (), 1498 sizeof (scc_entry) * size); 1499 1500 /* Update hash values of individual members by hashing in the 1501 index within the stable order. This ensures uniqueness. 1502 Also compute the SCC hash by mixing in all hash values in 1503 the stable order we obtained. */ 1504 sccstack[first].hash = *map.get (sccstack[first].t); 1505 scc_hash = sccstack[first].hash; 1506 for (unsigned i = 1; i < size; ++i) 1507 { 1508 sccstack[first+i].hash 1509 = iterative_hash_hashval_t (i, 1510 *map.get (sccstack[first+i].t)); 1511 scc_hash 1512 = iterative_hash_hashval_t (scc_hash, 1513 sccstack[first+i].hash); 1514 } 1515 } 1516 /* If we got a unique hash value for each tree, then sort already 1517 ensured entry-point independent order. Only compute the final 1518 SCC hash. 1519 1520 If we failed to find the unique entry point, we go by the same 1521 route. We will eventually introduce unwanted hash conflicts. */ 1522 else 1523 { 1524 scc_hash = sccstack[first].hash; 1525 for (unsigned i = 1; i < size; ++i) 1526 scc_hash 1527 = iterative_hash_hashval_t (scc_hash, sccstack[first+i].hash); 1528 1529 /* We cannot 100% guarantee that the hash won't conflict so as 1530 to make it impossible to find a unique hash. This however 1531 should be an extremely rare case. ICE for now so possible 1532 issues are found and evaluated. */ 1533 gcc_checking_assert (classes == size); 1534 } 1535 1536 /* To avoid conflicts across SCCs, iteratively hash the whole SCC 1537 hash into the hash of each element. */ 1538 for (unsigned i = 0; i < size; ++i) 1539 sccstack[first+i].hash 1540 = iterative_hash_hashval_t (sccstack[first+i].hash, scc_hash); 1541 return scc_hash; 1542 } 1543 1544 last_classes = classes; 1545 iterations++; 1546 1547 /* We failed to identify the entry point; propagate hash values across 1548 the edges. */ 1549 hash_map <tree, hashval_t> map(size*2); 1550 1551 for (unsigned i = 0; i < size; ++i) 1552 map.put (sccstack[first+i].t, sccstack[first+i].hash); 1553 1554 for (unsigned i = 0; i < size; i++) 1555 sccstack[first+i].hash 1556 = hash_tree (ob->writer_cache, &map, sccstack[first+i].t); 1557 } 1558 while (true); 1559 } 1560 1561 /* DFS walk EXPR and stream SCCs of tree bodies if they are not 1562 already in the streamer cache. Main routine called for 1563 each visit of EXPR. */ 1564 1565 void 1566 DFS::DFS_write_tree (struct output_block *ob, sccs *from_state, 1567 tree expr, bool ref_p, bool this_ref_p) 1568 { 1569 /* Handle special cases. */ 1570 if (expr == NULL_TREE) 1571 return; 1572 1573 /* Do not DFS walk into indexable trees. */ 1574 if (this_ref_p && tree_is_indexable (expr)) 1575 return; 1576 1577 /* Check if we already streamed EXPR. */ 1578 if (streamer_tree_cache_lookup (ob->writer_cache, expr, NULL)) 1579 return; 1580 1581 worklist w; 1582 w.expr = expr; 1583 w.from_state = from_state; 1584 w.cstate = NULL; 1585 w.ref_p = ref_p; 1586 w.this_ref_p = this_ref_p; 1587 worklist_vec.safe_push (w); 1588 } 1589 1590 1591 /* Emit the physical representation of tree node EXPR to output block OB. 1592 If THIS_REF_P is true, the leaves of EXPR are emitted as references via 1593 lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */ 1594 1595 void 1596 lto_output_tree (struct output_block *ob, tree expr, 1597 bool ref_p, bool this_ref_p) 1598 { 1599 unsigned ix; 1600 bool existed_p; 1601 1602 if (expr == NULL_TREE) 1603 { 1604 streamer_write_record_start (ob, LTO_null); 1605 return; 1606 } 1607 1608 if (this_ref_p && tree_is_indexable (expr)) 1609 { 1610 lto_output_tree_ref (ob, expr); 1611 return; 1612 } 1613 1614 existed_p = streamer_tree_cache_lookup (ob->writer_cache, expr, &ix); 1615 if (existed_p) 1616 { 1617 /* If a node has already been streamed out, make sure that 1618 we don't write it more than once. Otherwise, the reader 1619 will instantiate two different nodes for the same object. */ 1620 streamer_write_record_start (ob, LTO_tree_pickle_reference); 1621 streamer_write_uhwi (ob, ix); 1622 streamer_write_enum (ob->main_stream, LTO_tags, LTO_NUM_TAGS, 1623 lto_tree_code_to_tag (TREE_CODE (expr))); 1624 lto_stats.num_pickle_refs_output++; 1625 } 1626 else 1627 { 1628 /* This is the first time we see EXPR, write all reachable 1629 trees to OB. */ 1630 static bool in_dfs_walk; 1631 1632 /* Protect against recursion which means disconnect between 1633 what tree edges we walk in the DFS walk and what edges 1634 we stream out. */ 1635 gcc_assert (!in_dfs_walk); 1636 1637 /* Start the DFS walk. */ 1638 /* Save ob state ... */ 1639 /* let's see ... */ 1640 in_dfs_walk = true; 1641 DFS (ob, expr, ref_p, this_ref_p, false); 1642 in_dfs_walk = false; 1643 1644 /* Finally append a reference to the tree we were writing. 1645 ??? If expr ended up as a singleton we could have 1646 inlined it here and avoid outputting a reference. */ 1647 existed_p = streamer_tree_cache_lookup (ob->writer_cache, expr, &ix); 1648 gcc_assert (existed_p); 1649 streamer_write_record_start (ob, LTO_tree_pickle_reference); 1650 streamer_write_uhwi (ob, ix); 1651 streamer_write_enum (ob->main_stream, LTO_tags, LTO_NUM_TAGS, 1652 lto_tree_code_to_tag (TREE_CODE (expr))); 1653 lto_stats.num_pickle_refs_output++; 1654 } 1655 } 1656 1657 1658 /* Output to OB a list of try/catch handlers starting with FIRST. */ 1659 1660 static void 1661 output_eh_try_list (struct output_block *ob, eh_catch first) 1662 { 1663 eh_catch n; 1664 1665 for (n = first; n; n = n->next_catch) 1666 { 1667 streamer_write_record_start (ob, LTO_eh_catch); 1668 stream_write_tree (ob, n->type_list, true); 1669 stream_write_tree (ob, n->filter_list, true); 1670 stream_write_tree (ob, n->label, true); 1671 } 1672 1673 streamer_write_record_start (ob, LTO_null); 1674 } 1675 1676 1677 /* Output EH region R in function FN to OB. CURR_RN is the slot index 1678 that is being emitted in FN->EH->REGION_ARRAY. This is used to 1679 detect EH region sharing. */ 1680 1681 static void 1682 output_eh_region (struct output_block *ob, eh_region r) 1683 { 1684 enum LTO_tags tag; 1685 1686 if (r == NULL) 1687 { 1688 streamer_write_record_start (ob, LTO_null); 1689 return; 1690 } 1691 1692 if (r->type == ERT_CLEANUP) 1693 tag = LTO_ert_cleanup; 1694 else if (r->type == ERT_TRY) 1695 tag = LTO_ert_try; 1696 else if (r->type == ERT_ALLOWED_EXCEPTIONS) 1697 tag = LTO_ert_allowed_exceptions; 1698 else if (r->type == ERT_MUST_NOT_THROW) 1699 tag = LTO_ert_must_not_throw; 1700 else 1701 gcc_unreachable (); 1702 1703 streamer_write_record_start (ob, tag); 1704 streamer_write_hwi (ob, r->index); 1705 1706 if (r->outer) 1707 streamer_write_hwi (ob, r->outer->index); 1708 else 1709 streamer_write_zero (ob); 1710 1711 if (r->inner) 1712 streamer_write_hwi (ob, r->inner->index); 1713 else 1714 streamer_write_zero (ob); 1715 1716 if (r->next_peer) 1717 streamer_write_hwi (ob, r->next_peer->index); 1718 else 1719 streamer_write_zero (ob); 1720 1721 if (r->type == ERT_TRY) 1722 { 1723 output_eh_try_list (ob, r->u.eh_try.first_catch); 1724 } 1725 else if (r->type == ERT_ALLOWED_EXCEPTIONS) 1726 { 1727 stream_write_tree (ob, r->u.allowed.type_list, true); 1728 stream_write_tree (ob, r->u.allowed.label, true); 1729 streamer_write_uhwi (ob, r->u.allowed.filter); 1730 } 1731 else if (r->type == ERT_MUST_NOT_THROW) 1732 { 1733 stream_write_tree (ob, r->u.must_not_throw.failure_decl, true); 1734 bitpack_d bp = bitpack_create (ob->main_stream); 1735 stream_output_location (ob, &bp, r->u.must_not_throw.failure_loc); 1736 streamer_write_bitpack (&bp); 1737 } 1738 1739 if (r->landing_pads) 1740 streamer_write_hwi (ob, r->landing_pads->index); 1741 else 1742 streamer_write_zero (ob); 1743 } 1744 1745 1746 /* Output landing pad LP to OB. */ 1747 1748 static void 1749 output_eh_lp (struct output_block *ob, eh_landing_pad lp) 1750 { 1751 if (lp == NULL) 1752 { 1753 streamer_write_record_start (ob, LTO_null); 1754 return; 1755 } 1756 1757 streamer_write_record_start (ob, LTO_eh_landing_pad); 1758 streamer_write_hwi (ob, lp->index); 1759 if (lp->next_lp) 1760 streamer_write_hwi (ob, lp->next_lp->index); 1761 else 1762 streamer_write_zero (ob); 1763 1764 if (lp->region) 1765 streamer_write_hwi (ob, lp->region->index); 1766 else 1767 streamer_write_zero (ob); 1768 1769 stream_write_tree (ob, lp->post_landing_pad, true); 1770 } 1771 1772 1773 /* Output the existing eh_table to OB. */ 1774 1775 static void 1776 output_eh_regions (struct output_block *ob, struct function *fn) 1777 { 1778 if (fn->eh && fn->eh->region_tree) 1779 { 1780 unsigned i; 1781 eh_region eh; 1782 eh_landing_pad lp; 1783 tree ttype; 1784 1785 streamer_write_record_start (ob, LTO_eh_table); 1786 1787 /* Emit the index of the root of the EH region tree. */ 1788 streamer_write_hwi (ob, fn->eh->region_tree->index); 1789 1790 /* Emit all the EH regions in the region array. */ 1791 streamer_write_hwi (ob, vec_safe_length (fn->eh->region_array)); 1792 FOR_EACH_VEC_SAFE_ELT (fn->eh->region_array, i, eh) 1793 output_eh_region (ob, eh); 1794 1795 /* Emit all landing pads. */ 1796 streamer_write_hwi (ob, vec_safe_length (fn->eh->lp_array)); 1797 FOR_EACH_VEC_SAFE_ELT (fn->eh->lp_array, i, lp) 1798 output_eh_lp (ob, lp); 1799 1800 /* Emit all the runtime type data. */ 1801 streamer_write_hwi (ob, vec_safe_length (fn->eh->ttype_data)); 1802 FOR_EACH_VEC_SAFE_ELT (fn->eh->ttype_data, i, ttype) 1803 stream_write_tree (ob, ttype, true); 1804 1805 /* Emit the table of action chains. */ 1806 if (targetm.arm_eabi_unwinder) 1807 { 1808 tree t; 1809 streamer_write_hwi (ob, vec_safe_length (fn->eh->ehspec_data.arm_eabi)); 1810 FOR_EACH_VEC_SAFE_ELT (fn->eh->ehspec_data.arm_eabi, i, t) 1811 stream_write_tree (ob, t, true); 1812 } 1813 else 1814 { 1815 uchar c; 1816 streamer_write_hwi (ob, vec_safe_length (fn->eh->ehspec_data.other)); 1817 FOR_EACH_VEC_SAFE_ELT (fn->eh->ehspec_data.other, i, c) 1818 streamer_write_char_stream (ob->main_stream, c); 1819 } 1820 } 1821 1822 /* The LTO_null either terminates the record or indicates that there 1823 are no eh_records at all. */ 1824 streamer_write_record_start (ob, LTO_null); 1825 } 1826 1827 1828 /* Output all of the active ssa names to the ssa_names stream. */ 1829 1830 static void 1831 output_ssa_names (struct output_block *ob, struct function *fn) 1832 { 1833 unsigned int i, len; 1834 1835 len = vec_safe_length (SSANAMES (fn)); 1836 streamer_write_uhwi (ob, len); 1837 1838 for (i = 1; i < len; i++) 1839 { 1840 tree ptr = (*SSANAMES (fn))[i]; 1841 1842 if (ptr == NULL_TREE 1843 || SSA_NAME_IN_FREE_LIST (ptr) 1844 || virtual_operand_p (ptr) 1845 /* Simply skip unreleased SSA names. */ 1846 || (! SSA_NAME_IS_DEFAULT_DEF (ptr) 1847 && (! SSA_NAME_DEF_STMT (ptr) 1848 || ! gimple_bb (SSA_NAME_DEF_STMT (ptr))))) 1849 continue; 1850 1851 streamer_write_uhwi (ob, i); 1852 streamer_write_char_stream (ob->main_stream, 1853 SSA_NAME_IS_DEFAULT_DEF (ptr)); 1854 if (SSA_NAME_VAR (ptr)) 1855 stream_write_tree (ob, SSA_NAME_VAR (ptr), true); 1856 else 1857 /* ??? This drops SSA_NAME_IDENTIFIER on the floor. */ 1858 stream_write_tree (ob, TREE_TYPE (ptr), true); 1859 } 1860 1861 streamer_write_zero (ob); 1862 } 1863 1864 1865 1866 /* Output the cfg. */ 1867 1868 static void 1869 output_cfg (struct output_block *ob, struct function *fn) 1870 { 1871 struct lto_output_stream *tmp_stream = ob->main_stream; 1872 basic_block bb; 1873 1874 ob->main_stream = ob->cfg_stream; 1875 1876 streamer_write_enum (ob->main_stream, profile_status_d, PROFILE_LAST, 1877 profile_status_for_fn (fn)); 1878 1879 /* Output the number of the highest basic block. */ 1880 streamer_write_uhwi (ob, last_basic_block_for_fn (fn)); 1881 1882 FOR_ALL_BB_FN (bb, fn) 1883 { 1884 edge_iterator ei; 1885 edge e; 1886 1887 streamer_write_hwi (ob, bb->index); 1888 1889 /* Output the successors and the edge flags. */ 1890 streamer_write_uhwi (ob, EDGE_COUNT (bb->succs)); 1891 FOR_EACH_EDGE (e, ei, bb->succs) 1892 { 1893 streamer_write_uhwi (ob, e->dest->index); 1894 e->probability.stream_out (ob); 1895 streamer_write_uhwi (ob, e->flags); 1896 } 1897 } 1898 1899 streamer_write_hwi (ob, -1); 1900 1901 bb = ENTRY_BLOCK_PTR_FOR_FN (cfun); 1902 while (bb->next_bb) 1903 { 1904 streamer_write_hwi (ob, bb->next_bb->index); 1905 bb = bb->next_bb; 1906 } 1907 1908 streamer_write_hwi (ob, -1); 1909 1910 /* ??? The cfgloop interface is tied to cfun. */ 1911 gcc_assert (cfun == fn); 1912 1913 /* Output the number of loops. */ 1914 streamer_write_uhwi (ob, number_of_loops (fn)); 1915 1916 /* Output each loop, skipping the tree root which has number zero. */ 1917 for (unsigned i = 1; i < number_of_loops (fn); ++i) 1918 { 1919 struct loop *loop = get_loop (fn, i); 1920 1921 /* Write the index of the loop header. That's enough to rebuild 1922 the loop tree on the reader side. Stream -1 for an unused 1923 loop entry. */ 1924 if (!loop) 1925 { 1926 streamer_write_hwi (ob, -1); 1927 continue; 1928 } 1929 else 1930 streamer_write_hwi (ob, loop->header->index); 1931 1932 /* Write everything copy_loop_info copies. */ 1933 streamer_write_enum (ob->main_stream, 1934 loop_estimation, EST_LAST, loop->estimate_state); 1935 streamer_write_hwi (ob, loop->any_upper_bound); 1936 if (loop->any_upper_bound) 1937 streamer_write_widest_int (ob, loop->nb_iterations_upper_bound); 1938 streamer_write_hwi (ob, loop->any_likely_upper_bound); 1939 if (loop->any_likely_upper_bound) 1940 streamer_write_widest_int (ob, loop->nb_iterations_likely_upper_bound); 1941 streamer_write_hwi (ob, loop->any_estimate); 1942 if (loop->any_estimate) 1943 streamer_write_widest_int (ob, loop->nb_iterations_estimate); 1944 1945 /* Write OMP SIMD related info. */ 1946 streamer_write_hwi (ob, loop->safelen); 1947 streamer_write_hwi (ob, loop->unroll); 1948 streamer_write_hwi (ob, loop->dont_vectorize); 1949 streamer_write_hwi (ob, loop->force_vectorize); 1950 stream_write_tree (ob, loop->simduid, true); 1951 } 1952 1953 ob->main_stream = tmp_stream; 1954 } 1955 1956 1957 /* Create the header in the file using OB. If the section type is for 1958 a function, set FN to the decl for that function. */ 1959 1960 void 1961 produce_asm (struct output_block *ob, tree fn) 1962 { 1963 enum lto_section_type section_type = ob->section_type; 1964 struct lto_function_header header; 1965 char *section_name; 1966 1967 if (section_type == LTO_section_function_body) 1968 { 1969 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn)); 1970 section_name = lto_get_section_name (section_type, name, NULL); 1971 } 1972 else 1973 section_name = lto_get_section_name (section_type, NULL, NULL); 1974 1975 lto_begin_section (section_name, !flag_wpa); 1976 free (section_name); 1977 1978 /* The entire header is stream computed here. */ 1979 memset (&header, 0, sizeof (struct lto_function_header)); 1980 1981 /* Write the header. */ 1982 header.major_version = LTO_major_version; 1983 header.minor_version = LTO_minor_version; 1984 1985 if (section_type == LTO_section_function_body) 1986 header.cfg_size = ob->cfg_stream->total_size; 1987 header.main_size = ob->main_stream->total_size; 1988 header.string_size = ob->string_stream->total_size; 1989 lto_write_data (&header, sizeof header); 1990 1991 /* Put all of the gimple and the string table out the asm file as a 1992 block of text. */ 1993 if (section_type == LTO_section_function_body) 1994 lto_write_stream (ob->cfg_stream); 1995 lto_write_stream (ob->main_stream); 1996 lto_write_stream (ob->string_stream); 1997 1998 lto_end_section (); 1999 } 2000 2001 2002 /* Output the base body of struct function FN using output block OB. */ 2003 2004 static void 2005 output_struct_function_base (struct output_block *ob, struct function *fn) 2006 { 2007 struct bitpack_d bp; 2008 unsigned i; 2009 tree t; 2010 2011 /* Output the static chain and non-local goto save area. */ 2012 stream_write_tree (ob, fn->static_chain_decl, true); 2013 stream_write_tree (ob, fn->nonlocal_goto_save_area, true); 2014 2015 /* Output all the local variables in the function. */ 2016 streamer_write_hwi (ob, vec_safe_length (fn->local_decls)); 2017 FOR_EACH_VEC_SAFE_ELT (fn->local_decls, i, t) 2018 stream_write_tree (ob, t, true); 2019 2020 /* Output current IL state of the function. */ 2021 streamer_write_uhwi (ob, fn->curr_properties); 2022 2023 /* Write all the attributes for FN. */ 2024 bp = bitpack_create (ob->main_stream); 2025 bp_pack_value (&bp, fn->is_thunk, 1); 2026 bp_pack_value (&bp, fn->has_local_explicit_reg_vars, 1); 2027 bp_pack_value (&bp, fn->returns_pcc_struct, 1); 2028 bp_pack_value (&bp, fn->returns_struct, 1); 2029 bp_pack_value (&bp, fn->can_throw_non_call_exceptions, 1); 2030 bp_pack_value (&bp, fn->can_delete_dead_exceptions, 1); 2031 bp_pack_value (&bp, fn->always_inline_functions_inlined, 1); 2032 bp_pack_value (&bp, fn->after_inlining, 1); 2033 bp_pack_value (&bp, fn->stdarg, 1); 2034 bp_pack_value (&bp, fn->has_nonlocal_label, 1); 2035 bp_pack_value (&bp, fn->has_forced_label_in_static, 1); 2036 bp_pack_value (&bp, fn->calls_alloca, 1); 2037 bp_pack_value (&bp, fn->calls_setjmp, 1); 2038 bp_pack_value (&bp, fn->has_force_vectorize_loops, 1); 2039 bp_pack_value (&bp, fn->has_simduid_loops, 1); 2040 bp_pack_value (&bp, fn->va_list_fpr_size, 8); 2041 bp_pack_value (&bp, fn->va_list_gpr_size, 8); 2042 bp_pack_value (&bp, fn->last_clique, sizeof (short) * 8); 2043 2044 /* Output the function start and end loci. */ 2045 stream_output_location (ob, &bp, fn->function_start_locus); 2046 stream_output_location (ob, &bp, fn->function_end_locus); 2047 2048 streamer_write_bitpack (&bp); 2049 } 2050 2051 2052 /* Collect all leaf BLOCKs beyond ROOT into LEAFS. */ 2053 2054 static void 2055 collect_block_tree_leafs (tree root, vec<tree> &leafs) 2056 { 2057 for (root = BLOCK_SUBBLOCKS (root); root; root = BLOCK_CHAIN (root)) 2058 if (! BLOCK_SUBBLOCKS (root)) 2059 leafs.safe_push (root); 2060 else 2061 collect_block_tree_leafs (BLOCK_SUBBLOCKS (root), leafs); 2062 } 2063 2064 /* Output the body of function NODE->DECL. */ 2065 2066 static void 2067 output_function (struct cgraph_node *node) 2068 { 2069 tree function; 2070 struct function *fn; 2071 basic_block bb; 2072 struct output_block *ob; 2073 2074 function = node->decl; 2075 fn = DECL_STRUCT_FUNCTION (function); 2076 ob = create_output_block (LTO_section_function_body); 2077 2078 clear_line_info (ob); 2079 ob->symbol = node; 2080 2081 gcc_assert (current_function_decl == NULL_TREE && cfun == NULL); 2082 2083 /* Set current_function_decl and cfun. */ 2084 push_cfun (fn); 2085 2086 /* Make string 0 be a NULL string. */ 2087 streamer_write_char_stream (ob->string_stream, 0); 2088 2089 streamer_write_record_start (ob, LTO_function); 2090 2091 /* Output decls for parameters and args. */ 2092 stream_write_tree (ob, DECL_RESULT (function), true); 2093 streamer_write_chain (ob, DECL_ARGUMENTS (function), true); 2094 2095 /* Output debug args if available. */ 2096 vec<tree, va_gc> **debugargs = decl_debug_args_lookup (function); 2097 if (! debugargs) 2098 streamer_write_uhwi (ob, 0); 2099 else 2100 { 2101 streamer_write_uhwi (ob, (*debugargs)->length ()); 2102 for (unsigned i = 0; i < (*debugargs)->length (); ++i) 2103 stream_write_tree (ob, (**debugargs)[i], true); 2104 } 2105 2106 /* Output DECL_INITIAL for the function, which contains the tree of 2107 lexical scopes. */ 2108 stream_write_tree (ob, DECL_INITIAL (function), true); 2109 /* As we do not recurse into BLOCK_SUBBLOCKS but only BLOCK_SUPERCONTEXT 2110 collect block tree leafs and stream those. */ 2111 auto_vec<tree> block_tree_leafs; 2112 if (DECL_INITIAL (function)) 2113 collect_block_tree_leafs (DECL_INITIAL (function), block_tree_leafs); 2114 streamer_write_uhwi (ob, block_tree_leafs.length ()); 2115 for (unsigned i = 0; i < block_tree_leafs.length (); ++i) 2116 stream_write_tree (ob, block_tree_leafs[i], true); 2117 2118 /* We also stream abstract functions where we stream only stuff needed for 2119 debug info. */ 2120 if (gimple_has_body_p (function)) 2121 { 2122 streamer_write_uhwi (ob, 1); 2123 output_struct_function_base (ob, fn); 2124 2125 /* Output all the SSA names used in the function. */ 2126 output_ssa_names (ob, fn); 2127 2128 /* Output any exception handling regions. */ 2129 output_eh_regions (ob, fn); 2130 2131 2132 /* We will renumber the statements. The code that does this uses 2133 the same ordering that we use for serializing them so we can use 2134 the same code on the other end and not have to write out the 2135 statement numbers. We do not assign UIDs to PHIs here because 2136 virtual PHIs get re-computed on-the-fly which would make numbers 2137 inconsistent. */ 2138 set_gimple_stmt_max_uid (cfun, 0); 2139 FOR_ALL_BB_FN (bb, cfun) 2140 { 2141 for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi); 2142 gsi_next (&gsi)) 2143 { 2144 gphi *stmt = gsi.phi (); 2145 2146 /* Virtual PHIs are not going to be streamed. */ 2147 if (!virtual_operand_p (gimple_phi_result (stmt))) 2148 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun)); 2149 } 2150 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi); 2151 gsi_next (&gsi)) 2152 { 2153 gimple *stmt = gsi_stmt (gsi); 2154 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun)); 2155 } 2156 } 2157 /* To avoid keeping duplicate gimple IDs in the statements, renumber 2158 virtual phis now. */ 2159 FOR_ALL_BB_FN (bb, cfun) 2160 { 2161 for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi); 2162 gsi_next (&gsi)) 2163 { 2164 gphi *stmt = gsi.phi (); 2165 if (virtual_operand_p (gimple_phi_result (stmt))) 2166 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun)); 2167 } 2168 } 2169 2170 /* Output the code for the function. */ 2171 FOR_ALL_BB_FN (bb, fn) 2172 output_bb (ob, bb, fn); 2173 2174 /* The terminator for this function. */ 2175 streamer_write_record_start (ob, LTO_null); 2176 2177 output_cfg (ob, fn); 2178 2179 pop_cfun (); 2180 } 2181 else 2182 streamer_write_uhwi (ob, 0); 2183 2184 /* Create a section to hold the pickled output of this function. */ 2185 produce_asm (ob, function); 2186 2187 destroy_output_block (ob); 2188 } 2189 2190 /* Output the body of function NODE->DECL. */ 2191 2192 static void 2193 output_constructor (struct varpool_node *node) 2194 { 2195 tree var = node->decl; 2196 struct output_block *ob; 2197 2198 ob = create_output_block (LTO_section_function_body); 2199 2200 clear_line_info (ob); 2201 ob->symbol = node; 2202 2203 /* Make string 0 be a NULL string. */ 2204 streamer_write_char_stream (ob->string_stream, 0); 2205 2206 /* Output DECL_INITIAL for the function, which contains the tree of 2207 lexical scopes. */ 2208 stream_write_tree (ob, DECL_INITIAL (var), true); 2209 2210 /* Create a section to hold the pickled output of this function. */ 2211 produce_asm (ob, var); 2212 2213 destroy_output_block (ob); 2214 } 2215 2216 2217 /* Emit toplevel asms. */ 2218 2219 void 2220 lto_output_toplevel_asms (void) 2221 { 2222 struct output_block *ob; 2223 struct asm_node *can; 2224 char *section_name; 2225 struct lto_simple_header_with_strings header; 2226 2227 if (!symtab->first_asm_symbol ()) 2228 return; 2229 2230 ob = create_output_block (LTO_section_asm); 2231 2232 /* Make string 0 be a NULL string. */ 2233 streamer_write_char_stream (ob->string_stream, 0); 2234 2235 for (can = symtab->first_asm_symbol (); can; can = can->next) 2236 { 2237 streamer_write_string_cst (ob, ob->main_stream, can->asm_str); 2238 streamer_write_hwi (ob, can->order); 2239 } 2240 2241 streamer_write_string_cst (ob, ob->main_stream, NULL_TREE); 2242 2243 section_name = lto_get_section_name (LTO_section_asm, NULL, NULL); 2244 lto_begin_section (section_name, !flag_wpa); 2245 free (section_name); 2246 2247 /* The entire header stream is computed here. */ 2248 memset (&header, 0, sizeof (header)); 2249 2250 /* Write the header. */ 2251 header.major_version = LTO_major_version; 2252 header.minor_version = LTO_minor_version; 2253 2254 header.main_size = ob->main_stream->total_size; 2255 header.string_size = ob->string_stream->total_size; 2256 lto_write_data (&header, sizeof header); 2257 2258 /* Put all of the gimple and the string table out the asm file as a 2259 block of text. */ 2260 lto_write_stream (ob->main_stream); 2261 lto_write_stream (ob->string_stream); 2262 2263 lto_end_section (); 2264 2265 destroy_output_block (ob); 2266 } 2267 2268 2269 /* Copy the function body or variable constructor of NODE without deserializing. */ 2270 2271 static void 2272 copy_function_or_variable (struct symtab_node *node) 2273 { 2274 tree function = node->decl; 2275 struct lto_file_decl_data *file_data = node->lto_file_data; 2276 const char *data; 2277 size_t len; 2278 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function)); 2279 char *section_name = 2280 lto_get_section_name (LTO_section_function_body, name, NULL); 2281 size_t i, j; 2282 struct lto_in_decl_state *in_state; 2283 struct lto_out_decl_state *out_state = lto_get_out_decl_state (); 2284 2285 lto_begin_section (section_name, false); 2286 free (section_name); 2287 2288 /* We may have renamed the declaration, e.g., a static function. */ 2289 name = lto_get_decl_name_mapping (file_data, name); 2290 2291 data = lto_get_raw_section_data (file_data, LTO_section_function_body, 2292 name, &len); 2293 gcc_assert (data); 2294 2295 /* Do a bit copy of the function body. */ 2296 lto_write_raw_data (data, len); 2297 2298 /* Copy decls. */ 2299 in_state = 2300 lto_get_function_in_decl_state (node->lto_file_data, function); 2301 out_state->compressed = in_state->compressed; 2302 gcc_assert (in_state); 2303 2304 for (i = 0; i < LTO_N_DECL_STREAMS; i++) 2305 { 2306 size_t n = vec_safe_length (in_state->streams[i]); 2307 vec<tree, va_gc> *trees = in_state->streams[i]; 2308 struct lto_tree_ref_encoder *encoder = &(out_state->streams[i]); 2309 2310 /* The out state must have the same indices and the in state. 2311 So just copy the vector. All the encoders in the in state 2312 must be empty where we reach here. */ 2313 gcc_assert (lto_tree_ref_encoder_size (encoder) == 0); 2314 encoder->trees.reserve_exact (n); 2315 for (j = 0; j < n; j++) 2316 encoder->trees.safe_push ((*trees)[j]); 2317 } 2318 2319 lto_free_raw_section_data (file_data, LTO_section_function_body, name, 2320 data, len); 2321 lto_end_section (); 2322 } 2323 2324 /* Wrap symbol references in *TP inside a type-preserving MEM_REF. */ 2325 2326 static tree 2327 wrap_refs (tree *tp, int *ws, void *) 2328 { 2329 tree t = *tp; 2330 if (handled_component_p (t) 2331 && TREE_CODE (TREE_OPERAND (t, 0)) == VAR_DECL 2332 && TREE_PUBLIC (TREE_OPERAND (t, 0))) 2333 { 2334 tree decl = TREE_OPERAND (t, 0); 2335 tree ptrtype = build_pointer_type (TREE_TYPE (decl)); 2336 TREE_OPERAND (t, 0) = build2 (MEM_REF, TREE_TYPE (decl), 2337 build1 (ADDR_EXPR, ptrtype, decl), 2338 build_int_cst (ptrtype, 0)); 2339 TREE_THIS_VOLATILE (TREE_OPERAND (t, 0)) = TREE_THIS_VOLATILE (decl); 2340 *ws = 0; 2341 } 2342 else if (TREE_CODE (t) == CONSTRUCTOR) 2343 ; 2344 else if (!EXPR_P (t)) 2345 *ws = 0; 2346 return NULL_TREE; 2347 } 2348 2349 /* Remove functions that are no longer used from offload_funcs, and mark the 2350 remaining ones with DECL_PRESERVE_P. */ 2351 2352 static void 2353 prune_offload_funcs (void) 2354 { 2355 if (!offload_funcs) 2356 return; 2357 2358 unsigned int write_index = 0; 2359 for (unsigned read_index = 0; read_index < vec_safe_length (offload_funcs); 2360 read_index++) 2361 { 2362 tree fn_decl = (*offload_funcs)[read_index]; 2363 bool remove_p = cgraph_node::get (fn_decl) == NULL; 2364 if (remove_p) 2365 continue; 2366 2367 DECL_PRESERVE_P (fn_decl) = 1; 2368 2369 if (write_index != read_index) 2370 (*offload_funcs)[write_index] = (*offload_funcs)[read_index]; 2371 2372 write_index++; 2373 } 2374 2375 offload_funcs->truncate (write_index); 2376 } 2377 2378 /* Main entry point from the pass manager. */ 2379 2380 void 2381 lto_output (void) 2382 { 2383 struct lto_out_decl_state *decl_state; 2384 bitmap output = NULL; 2385 int i, n_nodes; 2386 lto_symtab_encoder_t encoder = lto_get_out_decl_state ()->symtab_node_encoder; 2387 2388 prune_offload_funcs (); 2389 2390 if (flag_checking) 2391 output = lto_bitmap_alloc (); 2392 2393 /* Initialize the streamer. */ 2394 lto_streamer_init (); 2395 2396 n_nodes = lto_symtab_encoder_size (encoder); 2397 /* Process only the functions with bodies. */ 2398 for (i = 0; i < n_nodes; i++) 2399 { 2400 symtab_node *snode = lto_symtab_encoder_deref (encoder, i); 2401 if (cgraph_node *node = dyn_cast <cgraph_node *> (snode)) 2402 { 2403 if (lto_symtab_encoder_encode_body_p (encoder, node) 2404 && !node->alias 2405 && (!node->thunk.thunk_p || !node->thunk.add_pointer_bounds_args)) 2406 { 2407 if (flag_checking) 2408 { 2409 gcc_assert (!bitmap_bit_p (output, DECL_UID (node->decl))); 2410 bitmap_set_bit (output, DECL_UID (node->decl)); 2411 } 2412 decl_state = lto_new_out_decl_state (); 2413 lto_push_out_decl_state (decl_state); 2414 if (gimple_has_body_p (node->decl) || !flag_wpa 2415 /* Thunks have no body but they may be synthetized 2416 at WPA time. */ 2417 || DECL_ARGUMENTS (node->decl)) 2418 output_function (node); 2419 else 2420 copy_function_or_variable (node); 2421 gcc_assert (lto_get_out_decl_state () == decl_state); 2422 lto_pop_out_decl_state (); 2423 lto_record_function_out_decl_state (node->decl, decl_state); 2424 } 2425 } 2426 else if (varpool_node *node = dyn_cast <varpool_node *> (snode)) 2427 { 2428 /* Wrap symbol references inside the ctor in a type 2429 preserving MEM_REF. */ 2430 tree ctor = DECL_INITIAL (node->decl); 2431 if (ctor && !in_lto_p) 2432 walk_tree (&ctor, wrap_refs, NULL, NULL); 2433 if (get_symbol_initial_value (encoder, node->decl) == error_mark_node 2434 && lto_symtab_encoder_encode_initializer_p (encoder, node) 2435 && !node->alias) 2436 { 2437 timevar_push (TV_IPA_LTO_CTORS_OUT); 2438 if (flag_checking) 2439 { 2440 gcc_assert (!bitmap_bit_p (output, DECL_UID (node->decl))); 2441 bitmap_set_bit (output, DECL_UID (node->decl)); 2442 } 2443 decl_state = lto_new_out_decl_state (); 2444 lto_push_out_decl_state (decl_state); 2445 if (DECL_INITIAL (node->decl) != error_mark_node 2446 || !flag_wpa) 2447 output_constructor (node); 2448 else 2449 copy_function_or_variable (node); 2450 gcc_assert (lto_get_out_decl_state () == decl_state); 2451 lto_pop_out_decl_state (); 2452 lto_record_function_out_decl_state (node->decl, decl_state); 2453 timevar_pop (TV_IPA_LTO_CTORS_OUT); 2454 } 2455 } 2456 } 2457 2458 /* Emit the callgraph after emitting function bodies. This needs to 2459 be done now to make sure that all the statements in every function 2460 have been renumbered so that edges can be associated with call 2461 statements using the statement UIDs. */ 2462 output_symtab (); 2463 2464 output_offload_tables (); 2465 2466 #if CHECKING_P 2467 lto_bitmap_free (output); 2468 #endif 2469 } 2470 2471 /* Write each node in encoded by ENCODER to OB, as well as those reachable 2472 from it and required for correct representation of its semantics. 2473 Each node in ENCODER must be a global declaration or a type. A node 2474 is written only once, even if it appears multiple times in the 2475 vector. Certain transitively-reachable nodes, such as those 2476 representing expressions, may be duplicated, but such nodes 2477 must not appear in ENCODER itself. */ 2478 2479 static void 2480 write_global_stream (struct output_block *ob, 2481 struct lto_tree_ref_encoder *encoder) 2482 { 2483 tree t; 2484 size_t index; 2485 const size_t size = lto_tree_ref_encoder_size (encoder); 2486 2487 for (index = 0; index < size; index++) 2488 { 2489 t = lto_tree_ref_encoder_get_tree (encoder, index); 2490 if (!streamer_tree_cache_lookup (ob->writer_cache, t, NULL)) 2491 stream_write_tree (ob, t, false); 2492 } 2493 } 2494 2495 2496 /* Write a sequence of indices into the globals vector corresponding 2497 to the trees in ENCODER. These are used by the reader to map the 2498 indices used to refer to global entities within function bodies to 2499 their referents. */ 2500 2501 static void 2502 write_global_references (struct output_block *ob, 2503 struct lto_tree_ref_encoder *encoder) 2504 { 2505 tree t; 2506 uint32_t index; 2507 const uint32_t size = lto_tree_ref_encoder_size (encoder); 2508 2509 /* Write size and slot indexes as 32-bit unsigned numbers. */ 2510 uint32_t *data = XNEWVEC (uint32_t, size + 1); 2511 data[0] = size; 2512 2513 for (index = 0; index < size; index++) 2514 { 2515 unsigned slot_num; 2516 2517 t = lto_tree_ref_encoder_get_tree (encoder, index); 2518 streamer_tree_cache_lookup (ob->writer_cache, t, &slot_num); 2519 gcc_assert (slot_num != (unsigned)-1); 2520 data[index + 1] = slot_num; 2521 } 2522 2523 lto_write_data (data, sizeof (int32_t) * (size + 1)); 2524 free (data); 2525 } 2526 2527 2528 /* Write all the streams in an lto_out_decl_state STATE using 2529 output block OB and output stream OUT_STREAM. */ 2530 2531 void 2532 lto_output_decl_state_streams (struct output_block *ob, 2533 struct lto_out_decl_state *state) 2534 { 2535 int i; 2536 2537 for (i = 0; i < LTO_N_DECL_STREAMS; i++) 2538 write_global_stream (ob, &state->streams[i]); 2539 } 2540 2541 2542 /* Write all the references in an lto_out_decl_state STATE using 2543 output block OB and output stream OUT_STREAM. */ 2544 2545 void 2546 lto_output_decl_state_refs (struct output_block *ob, 2547 struct lto_out_decl_state *state) 2548 { 2549 unsigned i; 2550 unsigned ref; 2551 tree decl; 2552 2553 /* Write reference to FUNCTION_DECL. If there is not function, 2554 write reference to void_type_node. */ 2555 decl = (state->fn_decl) ? state->fn_decl : void_type_node; 2556 streamer_tree_cache_lookup (ob->writer_cache, decl, &ref); 2557 gcc_assert (ref != (unsigned)-1); 2558 ref = ref * 2 + (state->compressed ? 1 : 0); 2559 lto_write_data (&ref, sizeof (uint32_t)); 2560 2561 for (i = 0; i < LTO_N_DECL_STREAMS; i++) 2562 write_global_references (ob, &state->streams[i]); 2563 } 2564 2565 2566 /* Return the written size of STATE. */ 2567 2568 static size_t 2569 lto_out_decl_state_written_size (struct lto_out_decl_state *state) 2570 { 2571 int i; 2572 size_t size; 2573 2574 size = sizeof (int32_t); /* fn_ref. */ 2575 for (i = 0; i < LTO_N_DECL_STREAMS; i++) 2576 { 2577 size += sizeof (int32_t); /* vector size. */ 2578 size += (lto_tree_ref_encoder_size (&state->streams[i]) 2579 * sizeof (int32_t)); 2580 } 2581 return size; 2582 } 2583 2584 2585 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote 2586 so far. */ 2587 2588 static void 2589 write_symbol (struct streamer_tree_cache_d *cache, 2590 tree t, hash_set<const char *> *seen, bool alias) 2591 { 2592 const char *name; 2593 enum gcc_plugin_symbol_kind kind; 2594 enum gcc_plugin_symbol_visibility visibility = GCCPV_DEFAULT; 2595 unsigned slot_num; 2596 uint64_t size; 2597 const char *comdat; 2598 unsigned char c; 2599 2600 gcc_checking_assert (TREE_PUBLIC (t) 2601 && !is_builtin_fn (t) 2602 && !DECL_ABSTRACT_P (t) 2603 && (!VAR_P (t) || !DECL_HARD_REGISTER (t))); 2604 2605 gcc_assert (VAR_OR_FUNCTION_DECL_P (t)); 2606 2607 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t)); 2608 2609 /* This behaves like assemble_name_raw in varasm.c, performing the 2610 same name manipulations that ASM_OUTPUT_LABELREF does. */ 2611 name = IDENTIFIER_POINTER ((*targetm.asm_out.mangle_assembler_name) (name)); 2612 2613 if (seen->add (name)) 2614 return; 2615 2616 streamer_tree_cache_lookup (cache, t, &slot_num); 2617 gcc_assert (slot_num != (unsigned)-1); 2618 2619 if (DECL_EXTERNAL (t)) 2620 { 2621 if (DECL_WEAK (t)) 2622 kind = GCCPK_WEAKUNDEF; 2623 else 2624 kind = GCCPK_UNDEF; 2625 } 2626 else 2627 { 2628 if (DECL_WEAK (t)) 2629 kind = GCCPK_WEAKDEF; 2630 else if (DECL_COMMON (t)) 2631 kind = GCCPK_COMMON; 2632 else 2633 kind = GCCPK_DEF; 2634 2635 /* When something is defined, it should have node attached. */ 2636 gcc_assert (alias || !VAR_P (t) || varpool_node::get (t)->definition); 2637 gcc_assert (alias || TREE_CODE (t) != FUNCTION_DECL 2638 || (cgraph_node::get (t) 2639 && cgraph_node::get (t)->definition)); 2640 } 2641 2642 /* Imitate what default_elf_asm_output_external do. 2643 When symbol is external, we need to output it with DEFAULT visibility 2644 when compiling with -fvisibility=default, while with HIDDEN visibility 2645 when symbol has attribute (visibility("hidden")) specified. 2646 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this 2647 right. */ 2648 2649 if (DECL_EXTERNAL (t) 2650 && !targetm.binds_local_p (t)) 2651 visibility = GCCPV_DEFAULT; 2652 else 2653 switch (DECL_VISIBILITY (t)) 2654 { 2655 case VISIBILITY_DEFAULT: 2656 visibility = GCCPV_DEFAULT; 2657 break; 2658 case VISIBILITY_PROTECTED: 2659 visibility = GCCPV_PROTECTED; 2660 break; 2661 case VISIBILITY_HIDDEN: 2662 visibility = GCCPV_HIDDEN; 2663 break; 2664 case VISIBILITY_INTERNAL: 2665 visibility = GCCPV_INTERNAL; 2666 break; 2667 } 2668 2669 if (kind == GCCPK_COMMON 2670 && DECL_SIZE_UNIT (t) 2671 && TREE_CODE (DECL_SIZE_UNIT (t)) == INTEGER_CST) 2672 size = TREE_INT_CST_LOW (DECL_SIZE_UNIT (t)); 2673 else 2674 size = 0; 2675 2676 if (DECL_ONE_ONLY (t)) 2677 comdat = IDENTIFIER_POINTER (decl_comdat_group_id (t)); 2678 else 2679 comdat = ""; 2680 2681 lto_write_data (name, strlen (name) + 1); 2682 lto_write_data (comdat, strlen (comdat) + 1); 2683 c = (unsigned char) kind; 2684 lto_write_data (&c, 1); 2685 c = (unsigned char) visibility; 2686 lto_write_data (&c, 1); 2687 lto_write_data (&size, 8); 2688 lto_write_data (&slot_num, 4); 2689 } 2690 2691 /* Write an IL symbol table to OB. 2692 SET and VSET are cgraph/varpool node sets we are outputting. */ 2693 2694 static void 2695 produce_symtab (struct output_block *ob) 2696 { 2697 struct streamer_tree_cache_d *cache = ob->writer_cache; 2698 char *section_name = lto_get_section_name (LTO_section_symtab, NULL, NULL); 2699 lto_symtab_encoder_t encoder = ob->decl_state->symtab_node_encoder; 2700 lto_symtab_encoder_iterator lsei; 2701 2702 lto_begin_section (section_name, false); 2703 free (section_name); 2704 2705 hash_set<const char *> seen; 2706 2707 /* Write the symbol table. 2708 First write everything defined and then all declarations. 2709 This is necessary to handle cases where we have duplicated symbols. */ 2710 for (lsei = lsei_start (encoder); 2711 !lsei_end_p (lsei); lsei_next (&lsei)) 2712 { 2713 symtab_node *node = lsei_node (lsei); 2714 2715 if (DECL_EXTERNAL (node->decl) || !node->output_to_lto_symbol_table_p ()) 2716 continue; 2717 write_symbol (cache, node->decl, &seen, false); 2718 } 2719 for (lsei = lsei_start (encoder); 2720 !lsei_end_p (lsei); lsei_next (&lsei)) 2721 { 2722 symtab_node *node = lsei_node (lsei); 2723 2724 if (!DECL_EXTERNAL (node->decl) || !node->output_to_lto_symbol_table_p ()) 2725 continue; 2726 write_symbol (cache, node->decl, &seen, false); 2727 } 2728 2729 lto_end_section (); 2730 } 2731 2732 2733 /* Init the streamer_mode_table for output, where we collect info on what 2734 machine_mode values have been streamed. */ 2735 void 2736 lto_output_init_mode_table (void) 2737 { 2738 memset (streamer_mode_table, '\0', MAX_MACHINE_MODE); 2739 } 2740 2741 2742 /* Write the mode table. */ 2743 static void 2744 lto_write_mode_table (void) 2745 { 2746 struct output_block *ob; 2747 ob = create_output_block (LTO_section_mode_table); 2748 bitpack_d bp = bitpack_create (ob->main_stream); 2749 2750 /* Ensure that for GET_MODE_INNER (m) != m we have 2751 also the inner mode marked. */ 2752 for (int i = 0; i < (int) MAX_MACHINE_MODE; i++) 2753 if (streamer_mode_table[i]) 2754 { 2755 machine_mode m = (machine_mode) i; 2756 machine_mode inner_m = GET_MODE_INNER (m); 2757 if (inner_m != m) 2758 streamer_mode_table[(int) inner_m] = 1; 2759 } 2760 /* First stream modes that have GET_MODE_INNER (m) == m, 2761 so that we can refer to them afterwards. */ 2762 for (int pass = 0; pass < 2; pass++) 2763 for (int i = 0; i < (int) MAX_MACHINE_MODE; i++) 2764 if (streamer_mode_table[i] && i != (int) VOIDmode && i != (int) BLKmode) 2765 { 2766 machine_mode m = (machine_mode) i; 2767 if ((GET_MODE_INNER (m) == m) ^ (pass == 0)) 2768 continue; 2769 bp_pack_value (&bp, m, 8); 2770 bp_pack_enum (&bp, mode_class, MAX_MODE_CLASS, GET_MODE_CLASS (m)); 2771 bp_pack_poly_value (&bp, GET_MODE_SIZE (m), 16); 2772 bp_pack_poly_value (&bp, GET_MODE_PRECISION (m), 16); 2773 bp_pack_value (&bp, GET_MODE_INNER (m), 8); 2774 bp_pack_poly_value (&bp, GET_MODE_NUNITS (m), 16); 2775 switch (GET_MODE_CLASS (m)) 2776 { 2777 case MODE_FRACT: 2778 case MODE_UFRACT: 2779 case MODE_ACCUM: 2780 case MODE_UACCUM: 2781 bp_pack_value (&bp, GET_MODE_IBIT (m), 8); 2782 bp_pack_value (&bp, GET_MODE_FBIT (m), 8); 2783 break; 2784 case MODE_FLOAT: 2785 case MODE_DECIMAL_FLOAT: 2786 bp_pack_string (ob, &bp, REAL_MODE_FORMAT (m)->name, true); 2787 break; 2788 default: 2789 break; 2790 } 2791 bp_pack_string (ob, &bp, GET_MODE_NAME (m), true); 2792 } 2793 bp_pack_value (&bp, VOIDmode, 8); 2794 2795 streamer_write_bitpack (&bp); 2796 2797 char *section_name 2798 = lto_get_section_name (LTO_section_mode_table, NULL, NULL); 2799 lto_begin_section (section_name, !flag_wpa); 2800 free (section_name); 2801 2802 /* The entire header stream is computed here. */ 2803 struct lto_simple_header_with_strings header; 2804 memset (&header, 0, sizeof (header)); 2805 2806 /* Write the header. */ 2807 header.major_version = LTO_major_version; 2808 header.minor_version = LTO_minor_version; 2809 2810 header.main_size = ob->main_stream->total_size; 2811 header.string_size = ob->string_stream->total_size; 2812 lto_write_data (&header, sizeof header); 2813 2814 /* Put all of the gimple and the string table out the asm file as a 2815 block of text. */ 2816 lto_write_stream (ob->main_stream); 2817 lto_write_stream (ob->string_stream); 2818 2819 lto_end_section (); 2820 destroy_output_block (ob); 2821 } 2822 2823 2824 /* This pass is run after all of the functions are serialized and all 2825 of the IPA passes have written their serialized forms. This pass 2826 causes the vector of all of the global decls and types used from 2827 this file to be written in to a section that can then be read in to 2828 recover these on other side. */ 2829 2830 void 2831 produce_asm_for_decls (void) 2832 { 2833 struct lto_out_decl_state *out_state; 2834 struct lto_out_decl_state *fn_out_state; 2835 struct lto_decl_header header; 2836 char *section_name; 2837 struct output_block *ob; 2838 unsigned idx, num_fns; 2839 size_t decl_state_size; 2840 int32_t num_decl_states; 2841 2842 ob = create_output_block (LTO_section_decls); 2843 2844 memset (&header, 0, sizeof (struct lto_decl_header)); 2845 2846 section_name = lto_get_section_name (LTO_section_decls, NULL, NULL); 2847 lto_begin_section (section_name, !flag_wpa); 2848 free (section_name); 2849 2850 /* Make string 0 be a NULL string. */ 2851 streamer_write_char_stream (ob->string_stream, 0); 2852 2853 gcc_assert (!alias_pairs); 2854 2855 /* Get rid of the global decl state hash tables to save some memory. */ 2856 out_state = lto_get_out_decl_state (); 2857 for (int i = 0; i < LTO_N_DECL_STREAMS; i++) 2858 if (out_state->streams[i].tree_hash_table) 2859 { 2860 delete out_state->streams[i].tree_hash_table; 2861 out_state->streams[i].tree_hash_table = NULL; 2862 } 2863 2864 /* Write the global symbols. */ 2865 lto_output_decl_state_streams (ob, out_state); 2866 num_fns = lto_function_decl_states.length (); 2867 for (idx = 0; idx < num_fns; idx++) 2868 { 2869 fn_out_state = 2870 lto_function_decl_states[idx]; 2871 lto_output_decl_state_streams (ob, fn_out_state); 2872 } 2873 2874 header.major_version = LTO_major_version; 2875 header.minor_version = LTO_minor_version; 2876 2877 /* Currently not used. This field would allow us to preallocate 2878 the globals vector, so that it need not be resized as it is extended. */ 2879 header.num_nodes = -1; 2880 2881 /* Compute the total size of all decl out states. */ 2882 decl_state_size = sizeof (int32_t); 2883 decl_state_size += lto_out_decl_state_written_size (out_state); 2884 for (idx = 0; idx < num_fns; idx++) 2885 { 2886 fn_out_state = 2887 lto_function_decl_states[idx]; 2888 decl_state_size += lto_out_decl_state_written_size (fn_out_state); 2889 } 2890 header.decl_state_size = decl_state_size; 2891 2892 header.main_size = ob->main_stream->total_size; 2893 header.string_size = ob->string_stream->total_size; 2894 2895 lto_write_data (&header, sizeof header); 2896 2897 /* Write the main out-decl state, followed by out-decl states of 2898 functions. */ 2899 num_decl_states = num_fns + 1; 2900 lto_write_data (&num_decl_states, sizeof (num_decl_states)); 2901 lto_output_decl_state_refs (ob, out_state); 2902 for (idx = 0; idx < num_fns; idx++) 2903 { 2904 fn_out_state = lto_function_decl_states[idx]; 2905 lto_output_decl_state_refs (ob, fn_out_state); 2906 } 2907 2908 lto_write_stream (ob->main_stream); 2909 lto_write_stream (ob->string_stream); 2910 2911 lto_end_section (); 2912 2913 /* Write the symbol table. It is used by linker to determine dependencies 2914 and thus we can skip it for WPA. */ 2915 if (!flag_wpa) 2916 produce_symtab (ob); 2917 2918 /* Write command line opts. */ 2919 lto_write_options (); 2920 2921 /* Deallocate memory and clean up. */ 2922 for (idx = 0; idx < num_fns; idx++) 2923 { 2924 fn_out_state = 2925 lto_function_decl_states[idx]; 2926 lto_delete_out_decl_state (fn_out_state); 2927 } 2928 lto_symtab_encoder_delete (ob->decl_state->symtab_node_encoder); 2929 lto_function_decl_states.release (); 2930 destroy_output_block (ob); 2931 if (lto_stream_offload_p) 2932 lto_write_mode_table (); 2933 } 2934