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