1 /* Symbol table. 2 Copyright (C) 2012-2019 Free Software Foundation, Inc. 3 Contributed by Jan Hubicka 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify it under 8 the terms of the GNU General Public License as published by the Free 9 Software Foundation; either version 3, or (at your option) any later 10 version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 #include "config.h" 22 #include "system.h" 23 #include "coretypes.h" 24 #include "backend.h" 25 #include "target.h" 26 #include "rtl.h" 27 #include "tree.h" 28 #include "gimple.h" 29 #include "timevar.h" 30 #include "cgraph.h" 31 #include "lto-streamer.h" 32 #include "print-tree.h" 33 #include "varasm.h" 34 #include "langhooks.h" 35 #include "output.h" 36 #include "ipa-utils.h" 37 #include "calls.h" 38 #include "stringpool.h" 39 #include "attribs.h" 40 #include "builtins.h" 41 42 static const char *ipa_ref_use_name[] = {"read","write","addr","alias"}; 43 44 const char * const ld_plugin_symbol_resolution_names[]= 45 { 46 "", 47 "undef", 48 "prevailing_def", 49 "prevailing_def_ironly", 50 "preempted_reg", 51 "preempted_ir", 52 "resolved_ir", 53 "resolved_exec", 54 "resolved_dyn", 55 "prevailing_def_ironly_exp" 56 }; 57 58 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at ALIAS 59 until we find an identifier that is not itself a transparent alias. */ 60 61 static inline tree 62 ultimate_transparent_alias_target (tree alias) 63 { 64 tree target = alias; 65 66 while (IDENTIFIER_TRANSPARENT_ALIAS (target)) 67 { 68 gcc_checking_assert (TREE_CHAIN (target)); 69 target = TREE_CHAIN (target); 70 } 71 gcc_checking_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target) 72 && ! TREE_CHAIN (target)); 73 74 return target; 75 } 76 77 78 /* Hash asmnames ignoring the user specified marks. */ 79 80 hashval_t 81 symbol_table::decl_assembler_name_hash (const_tree asmname) 82 { 83 if (IDENTIFIER_POINTER (asmname)[0] == '*') 84 { 85 const char *decl_str = IDENTIFIER_POINTER (asmname) + 1; 86 size_t ulp_len = strlen (user_label_prefix); 87 88 if (ulp_len == 0) 89 ; 90 else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0) 91 decl_str += ulp_len; 92 93 return htab_hash_string (decl_str); 94 } 95 96 return htab_hash_string (IDENTIFIER_POINTER (asmname)); 97 } 98 99 /* Return true if assembler names NAME1 and NAME2 leads to the same symbol 100 name. */ 101 102 bool 103 symbol_table::assembler_names_equal_p (const char *name1, const char *name2) 104 { 105 if (name1 != name2) 106 { 107 if (name1[0] == '*') 108 { 109 size_t ulp_len = strlen (user_label_prefix); 110 111 name1 ++; 112 113 if (ulp_len == 0) 114 ; 115 else if (strncmp (name1, user_label_prefix, ulp_len) == 0) 116 name1 += ulp_len; 117 else 118 return false; 119 } 120 if (name2[0] == '*') 121 { 122 size_t ulp_len = strlen (user_label_prefix); 123 124 name2 ++; 125 126 if (ulp_len == 0) 127 ; 128 else if (strncmp (name2, user_label_prefix, ulp_len) == 0) 129 name2 += ulp_len; 130 else 131 return false; 132 } 133 return !strcmp (name1, name2); 134 } 135 return true; 136 } 137 138 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */ 139 140 bool 141 symbol_table::decl_assembler_name_equal (tree decl, const_tree asmname) 142 { 143 tree decl_asmname = DECL_ASSEMBLER_NAME (decl); 144 const char *decl_str; 145 const char *asmname_str; 146 147 if (decl_asmname == asmname) 148 return true; 149 150 decl_str = IDENTIFIER_POINTER (decl_asmname); 151 asmname_str = IDENTIFIER_POINTER (asmname); 152 return assembler_names_equal_p (decl_str, asmname_str); 153 } 154 155 156 /* Returns nonzero if P1 and P2 are equal. */ 157 158 /* Insert NODE to assembler name hash. */ 159 160 void 161 symbol_table::insert_to_assembler_name_hash (symtab_node *node, 162 bool with_clones) 163 { 164 if (is_a <varpool_node *> (node) && DECL_HARD_REGISTER (node->decl)) 165 return; 166 gcc_checking_assert (!node->previous_sharing_asm_name 167 && !node->next_sharing_asm_name); 168 if (assembler_name_hash) 169 { 170 symtab_node **aslot; 171 cgraph_node *cnode; 172 tree decl = node->decl; 173 174 tree name = DECL_ASSEMBLER_NAME (node->decl); 175 176 /* C++ FE can produce decls without associated assembler name and insert 177 them to symtab to hold section or TLS information. */ 178 if (!name) 179 return; 180 181 hashval_t hash = decl_assembler_name_hash (name); 182 aslot = assembler_name_hash->find_slot_with_hash (name, hash, INSERT); 183 gcc_assert (*aslot != node); 184 node->next_sharing_asm_name = (symtab_node *)*aslot; 185 if (*aslot != NULL) 186 (*aslot)->previous_sharing_asm_name = node; 187 *aslot = node; 188 189 /* Update also possible inline clones sharing a decl. */ 190 cnode = dyn_cast <cgraph_node *> (node); 191 if (cnode && cnode->clones && with_clones) 192 for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone) 193 if (cnode->decl == decl) 194 insert_to_assembler_name_hash (cnode, true); 195 } 196 197 } 198 199 /* Remove NODE from assembler name hash. */ 200 201 void 202 symbol_table::unlink_from_assembler_name_hash (symtab_node *node, 203 bool with_clones) 204 { 205 if (assembler_name_hash) 206 { 207 cgraph_node *cnode; 208 tree decl = node->decl; 209 210 if (node->next_sharing_asm_name) 211 node->next_sharing_asm_name->previous_sharing_asm_name 212 = node->previous_sharing_asm_name; 213 if (node->previous_sharing_asm_name) 214 { 215 node->previous_sharing_asm_name->next_sharing_asm_name 216 = node->next_sharing_asm_name; 217 } 218 else 219 { 220 tree name = DECL_ASSEMBLER_NAME (node->decl); 221 symtab_node **slot; 222 223 if (!name) 224 return; 225 226 hashval_t hash = decl_assembler_name_hash (name); 227 slot = assembler_name_hash->find_slot_with_hash (name, hash, 228 NO_INSERT); 229 gcc_assert (*slot == node); 230 if (!node->next_sharing_asm_name) 231 assembler_name_hash->clear_slot (slot); 232 else 233 *slot = node->next_sharing_asm_name; 234 } 235 node->next_sharing_asm_name = NULL; 236 node->previous_sharing_asm_name = NULL; 237 238 /* Update also possible inline clones sharing a decl. */ 239 cnode = dyn_cast <cgraph_node *> (node); 240 if (cnode && cnode->clones && with_clones) 241 for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone) 242 if (cnode->decl == decl) 243 unlink_from_assembler_name_hash (cnode, true); 244 } 245 } 246 247 /* Arrange node to be first in its entry of assembler_name_hash. */ 248 249 void 250 symbol_table::symtab_prevail_in_asm_name_hash (symtab_node *node) 251 { 252 unlink_from_assembler_name_hash (node, false); 253 insert_to_assembler_name_hash (node, false); 254 } 255 256 /* Initalize asm name hash unless. */ 257 258 void 259 symbol_table::symtab_initialize_asm_name_hash (void) 260 { 261 symtab_node *node; 262 if (!assembler_name_hash) 263 { 264 assembler_name_hash = hash_table<asmname_hasher>::create_ggc (10); 265 FOR_EACH_SYMBOL (node) 266 insert_to_assembler_name_hash (node, false); 267 } 268 } 269 270 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */ 271 272 void 273 symbol_table::change_decl_assembler_name (tree decl, tree name) 274 { 275 symtab_node *node = NULL; 276 277 /* We can have user ASM names on things, like global register variables, that 278 are not in the symbol table. */ 279 if ((VAR_P (decl) && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))) 280 || TREE_CODE (decl) == FUNCTION_DECL) 281 node = symtab_node::get (decl); 282 if (!DECL_ASSEMBLER_NAME_SET_P (decl)) 283 { 284 SET_DECL_ASSEMBLER_NAME (decl, name); 285 if (node) 286 insert_to_assembler_name_hash (node, true); 287 } 288 else 289 { 290 if (name == DECL_ASSEMBLER_NAME (decl)) 291 return; 292 293 tree alias = (IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl)) 294 ? TREE_CHAIN (DECL_ASSEMBLER_NAME (decl)) 295 : NULL); 296 if (node) 297 unlink_from_assembler_name_hash (node, true); 298 299 const char *old_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 300 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) 301 && DECL_RTL_SET_P (decl)) 302 warning (0, "%qD renamed after being referenced in assembly", decl); 303 304 SET_DECL_ASSEMBLER_NAME (decl, name); 305 if (alias) 306 { 307 IDENTIFIER_TRANSPARENT_ALIAS (name) = 1; 308 TREE_CHAIN (name) = alias; 309 } 310 /* If we change assembler name, also all transparent aliases must 311 be updated. There are three kinds - those having same assembler name, 312 those being renamed in varasm.c and weakref being renamed by the 313 assembler. */ 314 if (node) 315 { 316 insert_to_assembler_name_hash (node, true); 317 ipa_ref *ref; 318 for (unsigned i = 0; node->iterate_direct_aliases (i, ref); i++) 319 { 320 struct symtab_node *alias = ref->referring; 321 if (alias->transparent_alias && !alias->weakref 322 && symbol_table::assembler_names_equal_p 323 (old_name, IDENTIFIER_POINTER ( 324 DECL_ASSEMBLER_NAME (alias->decl)))) 325 change_decl_assembler_name (alias->decl, name); 326 else if (alias->transparent_alias 327 && IDENTIFIER_TRANSPARENT_ALIAS (alias->decl)) 328 { 329 gcc_assert (TREE_CHAIN (DECL_ASSEMBLER_NAME (alias->decl)) 330 && IDENTIFIER_TRANSPARENT_ALIAS 331 (DECL_ASSEMBLER_NAME (alias->decl))); 332 333 TREE_CHAIN (DECL_ASSEMBLER_NAME (alias->decl)) = 334 ultimate_transparent_alias_target 335 (DECL_ASSEMBLER_NAME (node->decl)); 336 } 337 #ifdef ASM_OUTPUT_WEAKREF 338 else gcc_assert (!alias->transparent_alias || alias->weakref); 339 #else 340 else gcc_assert (!alias->transparent_alias); 341 #endif 342 } 343 gcc_assert (!node->transparent_alias || !node->definition 344 || node->weakref 345 || TREE_CHAIN (DECL_ASSEMBLER_NAME (decl)) 346 || symbol_table::assembler_names_equal_p 347 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), 348 IDENTIFIER_POINTER 349 (DECL_ASSEMBLER_NAME 350 (node->get_alias_target ()->decl)))); 351 } 352 } 353 } 354 355 /* Hash sections by their names. */ 356 357 hashval_t 358 section_name_hasher::hash (section_hash_entry *n) 359 { 360 return htab_hash_string (n->name); 361 } 362 363 /* Return true if section P1 name equals to P2. */ 364 365 bool 366 section_name_hasher::equal (section_hash_entry *n1, const char *name) 367 { 368 return n1->name == name || !strcmp (n1->name, name); 369 } 370 371 /* Add node into symbol table. This function is not used directly, but via 372 cgraph/varpool node creation routines. */ 373 374 void 375 symtab_node::register_symbol (void) 376 { 377 symtab->register_symbol (this); 378 379 if (!decl->decl_with_vis.symtab_node) 380 decl->decl_with_vis.symtab_node = this; 381 382 ref_list.clear (); 383 384 /* Be sure to do this last; C++ FE might create new nodes via 385 DECL_ASSEMBLER_NAME langhook! */ 386 symtab->insert_to_assembler_name_hash (this, false); 387 } 388 389 /* Remove NODE from same comdat group. */ 390 391 void 392 symtab_node::remove_from_same_comdat_group (void) 393 { 394 if (same_comdat_group) 395 { 396 symtab_node *prev; 397 for (prev = same_comdat_group; 398 prev->same_comdat_group != this; 399 prev = prev->same_comdat_group) 400 ; 401 if (same_comdat_group == prev) 402 prev->same_comdat_group = NULL; 403 else 404 prev->same_comdat_group = same_comdat_group; 405 same_comdat_group = NULL; 406 set_comdat_group (NULL); 407 } 408 } 409 410 /* Remove node from symbol table. This function is not used directly, but via 411 cgraph/varpool node removal routines. */ 412 413 void 414 symtab_node::unregister (void) 415 { 416 remove_all_references (); 417 remove_all_referring (); 418 419 /* Remove reference to section. */ 420 set_section_for_node (NULL); 421 422 remove_from_same_comdat_group (); 423 424 symtab->unregister (this); 425 426 /* During LTO symtab merging we temporarily corrupt decl to symtab node 427 hash. */ 428 gcc_assert (decl->decl_with_vis.symtab_node || in_lto_p); 429 if (decl->decl_with_vis.symtab_node == this) 430 { 431 symtab_node *replacement_node = NULL; 432 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this)) 433 replacement_node = cnode->find_replacement (); 434 decl->decl_with_vis.symtab_node = replacement_node; 435 } 436 if (!is_a <varpool_node *> (this) || !DECL_HARD_REGISTER (decl)) 437 symtab->unlink_from_assembler_name_hash (this, false); 438 if (in_init_priority_hash) 439 symtab->init_priority_hash->remove (this); 440 } 441 442 443 /* Remove symbol from symbol table. */ 444 445 void 446 symtab_node::remove (void) 447 { 448 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this)) 449 cnode->remove (); 450 else if (varpool_node *vnode = dyn_cast <varpool_node *> (this)) 451 vnode->remove (); 452 } 453 454 /* Add NEW_ to the same comdat group that OLD is in. */ 455 456 void 457 symtab_node::add_to_same_comdat_group (symtab_node *old_node) 458 { 459 gcc_assert (old_node->get_comdat_group ()); 460 gcc_assert (!same_comdat_group); 461 gcc_assert (this != old_node); 462 463 set_comdat_group (old_node->get_comdat_group ()); 464 same_comdat_group = old_node; 465 if (!old_node->same_comdat_group) 466 old_node->same_comdat_group = this; 467 else 468 { 469 symtab_node *n; 470 for (n = old_node->same_comdat_group; 471 n->same_comdat_group != old_node; 472 n = n->same_comdat_group) 473 ; 474 n->same_comdat_group = this; 475 } 476 } 477 478 /* Dissolve the same_comdat_group list in which NODE resides. */ 479 480 void 481 symtab_node::dissolve_same_comdat_group_list (void) 482 { 483 symtab_node *n = this; 484 symtab_node *next; 485 486 if (!same_comdat_group) 487 return; 488 do 489 { 490 next = n->same_comdat_group; 491 n->same_comdat_group = NULL; 492 /* Clear comdat_group for comdat locals, since 493 make_decl_local doesn't. */ 494 if (!TREE_PUBLIC (n->decl)) 495 n->set_comdat_group (NULL); 496 n = next; 497 } 498 while (n != this); 499 } 500 501 /* Return printable assembler name of NODE. 502 This function is used only for debugging. When assembler name 503 is unknown go with identifier name. */ 504 505 const char * 506 symtab_node::asm_name () const 507 { 508 if (!DECL_ASSEMBLER_NAME_SET_P (decl)) 509 return name (); 510 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 511 } 512 513 /* Return printable identifier name. */ 514 515 const char * 516 symtab_node::name () const 517 { 518 if (!DECL_NAME (decl)) 519 { 520 if (DECL_ASSEMBLER_NAME_SET_P (decl)) 521 return asm_name (); 522 else 523 return "<unnamed>"; 524 } 525 return lang_hooks.decl_printable_name (decl, 2); 526 } 527 528 const char * 529 symtab_node::get_dump_name (bool asm_name_p) const 530 { 531 #define EXTRA 16 532 const char *fname = asm_name_p ? asm_name () : name (); 533 unsigned l = strlen (fname); 534 535 char *s = (char *)ggc_internal_cleared_alloc (l + EXTRA); 536 snprintf (s, l + EXTRA, "%s/%d", fname, order); 537 538 return s; 539 } 540 541 const char * 542 symtab_node::dump_name () const 543 { 544 return get_dump_name (false); 545 } 546 547 const char * 548 symtab_node::dump_asm_name () const 549 { 550 return get_dump_name (true); 551 } 552 553 /* Return ipa reference from this symtab_node to 554 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type 555 of the use. */ 556 557 ipa_ref * 558 symtab_node::create_reference (symtab_node *referred_node, 559 enum ipa_ref_use use_type) 560 { 561 return create_reference (referred_node, use_type, NULL); 562 } 563 564 565 /* Return ipa reference from this symtab_node to 566 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type 567 of the use and STMT the statement (if it exists). */ 568 569 ipa_ref * 570 symtab_node::create_reference (symtab_node *referred_node, 571 enum ipa_ref_use use_type, gimple *stmt) 572 { 573 ipa_ref *ref = NULL, *ref2 = NULL; 574 ipa_ref_list *list, *list2; 575 ipa_ref_t *old_references; 576 577 gcc_checking_assert (!stmt || is_a <cgraph_node *> (this)); 578 gcc_checking_assert (use_type != IPA_REF_ALIAS || !stmt); 579 580 list = &ref_list; 581 old_references = vec_safe_address (list->references); 582 vec_safe_grow (list->references, vec_safe_length (list->references) + 1); 583 ref = &list->references->last (); 584 585 list2 = &referred_node->ref_list; 586 587 /* IPA_REF_ALIAS is always inserted at the beginning of the list. */ 588 if(use_type == IPA_REF_ALIAS) 589 { 590 list2->referring.safe_insert (0, ref); 591 ref->referred_index = 0; 592 593 for (unsigned int i = 1; i < list2->referring.length (); i++) 594 list2->referring[i]->referred_index = i; 595 } 596 else 597 { 598 list2->referring.safe_push (ref); 599 ref->referred_index = list2->referring.length () - 1; 600 } 601 602 ref->referring = this; 603 ref->referred = referred_node; 604 ref->stmt = stmt; 605 ref->lto_stmt_uid = 0; 606 ref->use = use_type; 607 ref->speculative = 0; 608 609 /* If vector was moved in memory, update pointers. */ 610 if (old_references != list->references->address ()) 611 { 612 int i; 613 for (i = 0; iterate_reference(i, ref2); i++) 614 ref2->referred_ref_list ()->referring[ref2->referred_index] = ref2; 615 } 616 return ref; 617 } 618 619 ipa_ref * 620 symtab_node::maybe_create_reference (tree val, gimple *stmt) 621 { 622 STRIP_NOPS (val); 623 ipa_ref_use use_type; 624 625 switch (TREE_CODE (val)) 626 { 627 case VAR_DECL: 628 use_type = IPA_REF_LOAD; 629 break; 630 case ADDR_EXPR: 631 use_type = IPA_REF_ADDR; 632 break; 633 default: 634 gcc_assert (!handled_component_p (val)); 635 return NULL; 636 } 637 638 val = get_base_var (val); 639 if (val && VAR_OR_FUNCTION_DECL_P (val)) 640 { 641 symtab_node *referred = symtab_node::get (val); 642 gcc_checking_assert (referred); 643 return create_reference (referred, use_type, stmt); 644 } 645 return NULL; 646 } 647 648 /* Clone all references from symtab NODE to this symtab_node. */ 649 650 void 651 symtab_node::clone_references (symtab_node *node) 652 { 653 ipa_ref *ref = NULL, *ref2 = NULL; 654 int i; 655 for (i = 0; node->iterate_reference (i, ref); i++) 656 { 657 bool speculative = ref->speculative; 658 unsigned int stmt_uid = ref->lto_stmt_uid; 659 660 ref2 = create_reference (ref->referred, ref->use, ref->stmt); 661 ref2->speculative = speculative; 662 ref2->lto_stmt_uid = stmt_uid; 663 } 664 } 665 666 /* Clone all referring from symtab NODE to this symtab_node. */ 667 668 void 669 symtab_node::clone_referring (symtab_node *node) 670 { 671 ipa_ref *ref = NULL, *ref2 = NULL; 672 int i; 673 for (i = 0; node->iterate_referring(i, ref); i++) 674 { 675 bool speculative = ref->speculative; 676 unsigned int stmt_uid = ref->lto_stmt_uid; 677 678 ref2 = ref->referring->create_reference (this, ref->use, ref->stmt); 679 ref2->speculative = speculative; 680 ref2->lto_stmt_uid = stmt_uid; 681 } 682 } 683 684 /* Clone reference REF to this symtab_node and set its stmt to STMT. */ 685 686 ipa_ref * 687 symtab_node::clone_reference (ipa_ref *ref, gimple *stmt) 688 { 689 bool speculative = ref->speculative; 690 unsigned int stmt_uid = ref->lto_stmt_uid; 691 ipa_ref *ref2; 692 693 ref2 = create_reference (ref->referred, ref->use, stmt); 694 ref2->speculative = speculative; 695 ref2->lto_stmt_uid = stmt_uid; 696 return ref2; 697 } 698 699 /* Find the structure describing a reference to REFERRED_NODE 700 and associated with statement STMT. */ 701 702 ipa_ref * 703 symtab_node::find_reference (symtab_node *referred_node, 704 gimple *stmt, unsigned int lto_stmt_uid) 705 { 706 ipa_ref *r = NULL; 707 int i; 708 709 for (i = 0; iterate_reference (i, r); i++) 710 if (r->referred == referred_node 711 && !r->speculative 712 && ((stmt && r->stmt == stmt) 713 || (lto_stmt_uid && r->lto_stmt_uid == lto_stmt_uid) 714 || (!stmt && !lto_stmt_uid && !r->stmt && !r->lto_stmt_uid))) 715 return r; 716 return NULL; 717 } 718 719 /* Remove all references that are associated with statement STMT. */ 720 721 void 722 symtab_node::remove_stmt_references (gimple *stmt) 723 { 724 ipa_ref *r = NULL; 725 int i = 0; 726 727 while (iterate_reference (i, r)) 728 if (r->stmt == stmt) 729 r->remove_reference (); 730 else 731 i++; 732 } 733 734 /* Remove all stmt references in non-speculative references. 735 Those are not maintained during inlining & clonning. 736 The exception are speculative references that are updated along 737 with callgraph edges associated with them. */ 738 739 void 740 symtab_node::clear_stmts_in_references (void) 741 { 742 ipa_ref *r = NULL; 743 int i; 744 745 for (i = 0; iterate_reference (i, r); i++) 746 if (!r->speculative) 747 { 748 r->stmt = NULL; 749 r->lto_stmt_uid = 0; 750 } 751 } 752 753 /* Remove all references in ref list. */ 754 755 void 756 symtab_node::remove_all_references (void) 757 { 758 while (vec_safe_length (ref_list.references)) 759 ref_list.references->last ().remove_reference (); 760 vec_free (ref_list.references); 761 } 762 763 /* Remove all referring items in ref list. */ 764 765 void 766 symtab_node::remove_all_referring (void) 767 { 768 while (ref_list.referring.length ()) 769 ref_list.referring.last ()->remove_reference (); 770 ref_list.referring.release (); 771 } 772 773 /* Dump references in ref list to FILE. */ 774 775 void 776 symtab_node::dump_references (FILE *file) 777 { 778 ipa_ref *ref = NULL; 779 int i; 780 for (i = 0; iterate_reference (i, ref); i++) 781 { 782 fprintf (file, "%s (%s)", 783 ref->referred->dump_asm_name (), 784 ipa_ref_use_name [ref->use]); 785 if (ref->speculative) 786 fprintf (file, " (speculative)"); 787 } 788 fprintf (file, "\n"); 789 } 790 791 /* Dump referring in list to FILE. */ 792 793 void 794 symtab_node::dump_referring (FILE *file) 795 { 796 ipa_ref *ref = NULL; 797 int i; 798 for (i = 0; iterate_referring(i, ref); i++) 799 { 800 fprintf (file, "%s (%s)", 801 ref->referring->dump_asm_name (), 802 ipa_ref_use_name [ref->use]); 803 if (ref->speculative) 804 fprintf (file, " (speculative)"); 805 } 806 fprintf (file, "\n"); 807 } 808 809 static const char * const symtab_type_names[] = {"symbol", "function", "variable"}; 810 811 /* Dump base fields of symtab nodes to F. Not to be used directly. */ 812 813 void 814 symtab_node::dump_base (FILE *f) 815 { 816 static const char * const visibility_types[] = { 817 "default", "protected", "hidden", "internal" 818 }; 819 820 fprintf (f, "%s (%s)", dump_asm_name (), name ()); 821 dump_addr (f, " @", (void *)this); 822 fprintf (f, "\n Type: %s", symtab_type_names[type]); 823 824 if (definition) 825 fprintf (f, " definition"); 826 if (analyzed) 827 fprintf (f, " analyzed"); 828 if (alias) 829 fprintf (f, " alias"); 830 if (transparent_alias) 831 fprintf (f, " transparent_alias"); 832 if (weakref) 833 fprintf (f, " weakref"); 834 if (cpp_implicit_alias) 835 fprintf (f, " cpp_implicit_alias"); 836 if (alias_target) 837 fprintf (f, " target:%s", 838 DECL_P (alias_target) 839 ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME 840 (alias_target)) 841 : IDENTIFIER_POINTER (alias_target)); 842 if (body_removed) 843 fprintf (f, "\n Body removed by symtab_remove_unreachable_nodes"); 844 fprintf (f, "\n Visibility:"); 845 if (in_other_partition) 846 fprintf (f, " in_other_partition"); 847 if (used_from_other_partition) 848 fprintf (f, " used_from_other_partition"); 849 if (force_output) 850 fprintf (f, " force_output"); 851 if (forced_by_abi) 852 fprintf (f, " forced_by_abi"); 853 if (externally_visible) 854 fprintf (f, " externally_visible"); 855 if (no_reorder) 856 fprintf (f, " no_reorder"); 857 if (resolution != LDPR_UNKNOWN) 858 fprintf (f, " %s", 859 ld_plugin_symbol_resolution_names[(int)resolution]); 860 if (TREE_ASM_WRITTEN (decl)) 861 fprintf (f, " asm_written"); 862 if (DECL_EXTERNAL (decl)) 863 fprintf (f, " external"); 864 if (TREE_PUBLIC (decl)) 865 fprintf (f, " public"); 866 if (DECL_COMMON (decl)) 867 fprintf (f, " common"); 868 if (DECL_WEAK (decl)) 869 fprintf (f, " weak"); 870 if (DECL_DLLIMPORT_P (decl)) 871 fprintf (f, " dll_import"); 872 if (DECL_COMDAT (decl)) 873 fprintf (f, " comdat"); 874 if (get_comdat_group ()) 875 fprintf (f, " comdat_group:%s", 876 IDENTIFIER_POINTER (get_comdat_group_id ())); 877 if (DECL_ONE_ONLY (decl)) 878 fprintf (f, " one_only"); 879 if (get_section ()) 880 fprintf (f, " section:%s", 881 get_section ()); 882 if (implicit_section) 883 fprintf (f," (implicit_section)"); 884 if (DECL_VISIBILITY_SPECIFIED (decl)) 885 fprintf (f, " visibility_specified"); 886 if (DECL_VISIBILITY (decl)) 887 fprintf (f, " visibility:%s", 888 visibility_types [DECL_VISIBILITY (decl)]); 889 if (DECL_VIRTUAL_P (decl)) 890 fprintf (f, " virtual"); 891 if (DECL_ARTIFICIAL (decl)) 892 fprintf (f, " artificial"); 893 if (TREE_CODE (decl) == FUNCTION_DECL) 894 { 895 if (DECL_STATIC_CONSTRUCTOR (decl)) 896 fprintf (f, " constructor"); 897 if (DECL_STATIC_DESTRUCTOR (decl)) 898 fprintf (f, " destructor"); 899 } 900 fprintf (f, "\n"); 901 902 if (same_comdat_group) 903 fprintf (f, " Same comdat group as: %s\n", 904 same_comdat_group->dump_asm_name ()); 905 if (next_sharing_asm_name) 906 fprintf (f, " next sharing asm name: %i\n", 907 next_sharing_asm_name->order); 908 if (previous_sharing_asm_name) 909 fprintf (f, " previous sharing asm name: %i\n", 910 previous_sharing_asm_name->order); 911 912 if (address_taken) 913 fprintf (f, " Address is taken.\n"); 914 if (aux) 915 { 916 fprintf (f, " Aux:"); 917 dump_addr (f, " @", (void *)aux); 918 fprintf (f, "\n"); 919 } 920 921 fprintf (f, " References: "); 922 dump_references (f); 923 fprintf (f, " Referring: "); 924 dump_referring (f); 925 if (lto_file_data) 926 fprintf (f, " Read from file: %s\n", 927 lto_file_data->file_name); 928 } 929 930 /* Dump symtab node to F. */ 931 932 void 933 symtab_node::dump (FILE *f) 934 { 935 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this)) 936 cnode->dump (f); 937 else if (varpool_node *vnode = dyn_cast <varpool_node *> (this)) 938 vnode->dump (f); 939 } 940 941 void 942 symbol_table::dump (FILE *f) 943 { 944 symtab_node *node; 945 fprintf (f, "Symbol table:\n\n"); 946 FOR_EACH_SYMBOL (node) 947 node->dump (f); 948 } 949 950 DEBUG_FUNCTION void 951 symbol_table::debug (void) 952 { 953 dump (stderr); 954 } 955 956 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME. 957 Return NULL if there's no such node. */ 958 959 symtab_node * 960 symtab_node::get_for_asmname (const_tree asmname) 961 { 962 symtab_node *node; 963 964 symtab->symtab_initialize_asm_name_hash (); 965 hashval_t hash = symtab->decl_assembler_name_hash (asmname); 966 symtab_node **slot 967 = symtab->assembler_name_hash->find_slot_with_hash (asmname, hash, 968 NO_INSERT); 969 970 if (slot) 971 { 972 node = *slot; 973 return node; 974 } 975 return NULL; 976 } 977 978 /* Dump symtab node NODE to stderr. */ 979 980 DEBUG_FUNCTION void 981 symtab_node::debug (void) 982 { 983 dump (stderr); 984 } 985 986 /* Verify common part of symtab nodes. */ 987 988 DEBUG_FUNCTION bool 989 symtab_node::verify_base (void) 990 { 991 bool error_found = false; 992 symtab_node *hashed_node; 993 994 if (is_a <cgraph_node *> (this)) 995 { 996 if (TREE_CODE (decl) != FUNCTION_DECL) 997 { 998 error ("function symbol is not function"); 999 error_found = true; 1000 } 1001 else if ((lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl)) 1002 != NULL) 1003 != dyn_cast <cgraph_node *> (this)->ifunc_resolver) 1004 { 1005 error ("inconsistent %<ifunc%> attribute"); 1006 error_found = true; 1007 } 1008 } 1009 else if (is_a <varpool_node *> (this)) 1010 { 1011 if (!VAR_P (decl)) 1012 { 1013 error ("variable symbol is not variable"); 1014 error_found = true; 1015 } 1016 } 1017 else 1018 { 1019 error ("node has unknown type"); 1020 error_found = true; 1021 } 1022 1023 if (symtab->state != LTO_STREAMING) 1024 { 1025 hashed_node = symtab_node::get (decl); 1026 if (!hashed_node) 1027 { 1028 error ("node not found node->decl->decl_with_vis.symtab_node"); 1029 error_found = true; 1030 } 1031 if (hashed_node != this 1032 && (!is_a <cgraph_node *> (this) 1033 || !dyn_cast <cgraph_node *> (this)->clone_of 1034 || dyn_cast <cgraph_node *> (this)->clone_of->decl != decl)) 1035 { 1036 error ("node differs from node->decl->decl_with_vis.symtab_node"); 1037 error_found = true; 1038 } 1039 } 1040 if (symtab->assembler_name_hash) 1041 { 1042 hashed_node = symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl)); 1043 if (hashed_node) 1044 { 1045 if (hashed_node->previous_sharing_asm_name) 1046 { 1047 error ("assembler name hash list corrupted"); 1048 error_found = true; 1049 } 1050 else if (previous_sharing_asm_name == NULL) 1051 { 1052 if (hashed_node != this) 1053 { 1054 error ("assembler name hash list corrupted"); 1055 error_found = true; 1056 } 1057 } 1058 else if (!(is_a <varpool_node *> (this) && DECL_HARD_REGISTER (decl))) 1059 { 1060 if (!asmname_hasher::equal (previous_sharing_asm_name, 1061 DECL_ASSEMBLER_NAME (decl))) 1062 { 1063 error ("node not found in symtab assembler name hash"); 1064 error_found = true; 1065 } 1066 } 1067 } 1068 } 1069 if (previous_sharing_asm_name 1070 && previous_sharing_asm_name->next_sharing_asm_name != this) 1071 { 1072 error ("double linked list of assembler names corrupted"); 1073 error_found = true; 1074 } 1075 if (body_removed && definition) 1076 { 1077 error ("node has body_removed but is definition"); 1078 error_found = true; 1079 } 1080 if (analyzed && !definition) 1081 { 1082 error ("node is analyzed but it is not a definition"); 1083 error_found = true; 1084 } 1085 if (cpp_implicit_alias && !alias) 1086 { 1087 error ("node is alias but not implicit alias"); 1088 error_found = true; 1089 } 1090 if (alias && !definition && !weakref) 1091 { 1092 error ("node is alias but not definition"); 1093 error_found = true; 1094 } 1095 if (weakref && !transparent_alias) 1096 { 1097 error ("node is weakref but not an transparent_alias"); 1098 error_found = true; 1099 } 1100 if (transparent_alias && !alias) 1101 { 1102 error ("node is transparent_alias but not an alias"); 1103 error_found = true; 1104 } 1105 if (same_comdat_group) 1106 { 1107 symtab_node *n = same_comdat_group; 1108 1109 if (!n->get_comdat_group ()) 1110 { 1111 error ("node is in same_comdat_group list but has no comdat_group"); 1112 error_found = true; 1113 } 1114 if (n->get_comdat_group () != get_comdat_group ()) 1115 { 1116 error ("same_comdat_group list across different groups"); 1117 error_found = true; 1118 } 1119 if (n->type != type) 1120 { 1121 error ("mixing different types of symbol in same comdat groups is not supported"); 1122 error_found = true; 1123 } 1124 if (n == this) 1125 { 1126 error ("node is alone in a comdat group"); 1127 error_found = true; 1128 } 1129 do 1130 { 1131 if (!n->same_comdat_group) 1132 { 1133 error ("same_comdat_group is not a circular list"); 1134 error_found = true; 1135 break; 1136 } 1137 n = n->same_comdat_group; 1138 } 1139 while (n != this); 1140 if (comdat_local_p ()) 1141 { 1142 ipa_ref *ref = NULL; 1143 1144 for (int i = 0; iterate_referring (i, ref); ++i) 1145 { 1146 if (!in_same_comdat_group_p (ref->referring)) 1147 { 1148 error ("comdat-local symbol referred to by %s outside its " 1149 "comdat", 1150 identifier_to_locale (ref->referring->name())); 1151 error_found = true; 1152 } 1153 } 1154 } 1155 } 1156 if (implicit_section && !get_section ()) 1157 { 1158 error ("implicit_section flag is set but section isn%'t"); 1159 error_found = true; 1160 } 1161 if (get_section () && get_comdat_group () 1162 && !implicit_section 1163 && !lookup_attribute ("section", DECL_ATTRIBUTES (decl))) 1164 { 1165 error ("Both section and comdat group is set"); 1166 error_found = true; 1167 } 1168 /* TODO: Add string table for sections, so we do not keep holding duplicated 1169 strings. */ 1170 if (alias && definition 1171 && get_section () != get_alias_target ()->get_section () 1172 && (!get_section() 1173 || !get_alias_target ()->get_section () 1174 || strcmp (get_section(), 1175 get_alias_target ()->get_section ()))) 1176 { 1177 error ("Alias and target%'s section differs"); 1178 get_alias_target ()->dump (stderr); 1179 error_found = true; 1180 } 1181 if (alias && definition 1182 && get_comdat_group () != get_alias_target ()->get_comdat_group ()) 1183 { 1184 error ("Alias and target%'s comdat groups differs"); 1185 get_alias_target ()->dump (stderr); 1186 error_found = true; 1187 } 1188 if (transparent_alias && definition && !weakref) 1189 { 1190 symtab_node *to = get_alias_target (); 1191 const char *name1 1192 = IDENTIFIER_POINTER ( 1193 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (decl))); 1194 const char *name2 1195 = IDENTIFIER_POINTER ( 1196 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (to->decl))); 1197 if (!symbol_table::assembler_names_equal_p (name1, name2)) 1198 { 1199 error ("Transparent alias and target%'s assembler names differs"); 1200 get_alias_target ()->dump (stderr); 1201 error_found = true; 1202 } 1203 } 1204 if (transparent_alias && definition 1205 && get_alias_target()->transparent_alias && get_alias_target()->analyzed) 1206 { 1207 error ("Chained transparent aliases"); 1208 get_alias_target ()->dump (stderr); 1209 error_found = true; 1210 } 1211 1212 return error_found; 1213 } 1214 1215 /* Verify consistency of NODE. */ 1216 1217 DEBUG_FUNCTION void 1218 symtab_node::verify (void) 1219 { 1220 if (seen_error ()) 1221 return; 1222 1223 timevar_push (TV_CGRAPH_VERIFY); 1224 if (cgraph_node *node = dyn_cast <cgraph_node *> (this)) 1225 node->verify_node (); 1226 else 1227 if (verify_base ()) 1228 { 1229 debug (); 1230 internal_error ("symtab_node::verify failed"); 1231 } 1232 timevar_pop (TV_CGRAPH_VERIFY); 1233 } 1234 1235 /* Verify symbol table for internal consistency. */ 1236 1237 DEBUG_FUNCTION void 1238 symtab_node::verify_symtab_nodes (void) 1239 { 1240 symtab_node *node; 1241 hash_map<tree, symtab_node *> comdat_head_map (251); 1242 1243 FOR_EACH_SYMBOL (node) 1244 { 1245 node->verify (); 1246 if (node->get_comdat_group ()) 1247 { 1248 symtab_node **entry, *s; 1249 bool existed; 1250 1251 entry = &comdat_head_map.get_or_insert (node->get_comdat_group (), 1252 &existed); 1253 if (!existed) 1254 *entry = node; 1255 else if (!DECL_EXTERNAL (node->decl)) 1256 { 1257 for (s = (*entry)->same_comdat_group; 1258 s != NULL && s != node && s != *entry; 1259 s = s->same_comdat_group) 1260 ; 1261 if (!s || s == *entry) 1262 { 1263 error ("Two symbols with same comdat_group are not linked by " 1264 "the same_comdat_group list."); 1265 (*entry)->debug (); 1266 node->debug (); 1267 internal_error ("symtab_node::verify failed"); 1268 } 1269 } 1270 } 1271 } 1272 } 1273 1274 /* Make DECL local. FIXME: We shouldn't need to mess with rtl this early, 1275 but other code such as notice_global_symbol generates rtl. */ 1276 1277 void 1278 symtab_node::make_decl_local (void) 1279 { 1280 rtx rtl, symbol; 1281 1282 if (weakref) 1283 { 1284 weakref = false; 1285 IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl)) = 0; 1286 TREE_CHAIN (DECL_ASSEMBLER_NAME (decl)) = NULL_TREE; 1287 symtab->change_decl_assembler_name 1288 (decl, DECL_ASSEMBLER_NAME (get_alias_target ()->decl)); 1289 DECL_ATTRIBUTES (decl) = remove_attribute ("weakref", 1290 DECL_ATTRIBUTES (decl)); 1291 } 1292 /* Avoid clearing comdat_groups on comdat-local decls. */ 1293 else if (TREE_PUBLIC (decl) == 0) 1294 return; 1295 1296 /* Localizing a symbol also make all its transparent aliases local. */ 1297 ipa_ref *ref; 1298 for (unsigned i = 0; iterate_direct_aliases (i, ref); i++) 1299 { 1300 struct symtab_node *alias = ref->referring; 1301 if (alias->transparent_alias) 1302 alias->make_decl_local (); 1303 } 1304 1305 if (VAR_P (decl)) 1306 { 1307 DECL_COMMON (decl) = 0; 1308 /* ADDRESSABLE flag is not defined for public symbols. */ 1309 TREE_ADDRESSABLE (decl) = 1; 1310 TREE_STATIC (decl) = 1; 1311 } 1312 else 1313 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL); 1314 1315 DECL_COMDAT (decl) = 0; 1316 DECL_WEAK (decl) = 0; 1317 DECL_EXTERNAL (decl) = 0; 1318 DECL_VISIBILITY_SPECIFIED (decl) = 0; 1319 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT; 1320 TREE_PUBLIC (decl) = 0; 1321 DECL_DLLIMPORT_P (decl) = 0; 1322 if (!DECL_RTL_SET_P (decl)) 1323 return; 1324 1325 /* Update rtl flags. */ 1326 make_decl_rtl (decl); 1327 1328 rtl = DECL_RTL (decl); 1329 if (!MEM_P (rtl)) 1330 return; 1331 1332 symbol = XEXP (rtl, 0); 1333 if (GET_CODE (symbol) != SYMBOL_REF) 1334 return; 1335 1336 SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl); 1337 } 1338 1339 /* Copy visibility from N. 1340 This is useful when THIS becomes a transparent alias of N. */ 1341 1342 void 1343 symtab_node::copy_visibility_from (symtab_node *n) 1344 { 1345 gcc_checking_assert (n->weakref == weakref); 1346 1347 ipa_ref *ref; 1348 for (unsigned i = 0; iterate_direct_aliases (i, ref); i++) 1349 { 1350 struct symtab_node *alias = ref->referring; 1351 if (alias->transparent_alias) 1352 alias->copy_visibility_from (n); 1353 } 1354 1355 if (VAR_P (decl)) 1356 { 1357 DECL_COMMON (decl) = DECL_COMMON (n->decl); 1358 /* ADDRESSABLE flag is not defined for public symbols. */ 1359 if (TREE_PUBLIC (decl) && !TREE_PUBLIC (n->decl)) 1360 TREE_ADDRESSABLE (decl) = 1; 1361 TREE_STATIC (decl) = TREE_STATIC (n->decl); 1362 } 1363 else gcc_assert (TREE_CODE (decl) == FUNCTION_DECL); 1364 1365 DECL_COMDAT (decl) = DECL_COMDAT (n->decl); 1366 DECL_WEAK (decl) = DECL_WEAK (n->decl); 1367 DECL_EXTERNAL (decl) = DECL_EXTERNAL (n->decl); 1368 DECL_VISIBILITY_SPECIFIED (decl) = DECL_VISIBILITY_SPECIFIED (n->decl); 1369 DECL_VISIBILITY (decl) = DECL_VISIBILITY (n->decl); 1370 TREE_PUBLIC (decl) = TREE_PUBLIC (n->decl); 1371 DECL_DLLIMPORT_P (decl) = DECL_DLLIMPORT_P (n->decl); 1372 resolution = n->resolution; 1373 set_comdat_group (n->get_comdat_group ()); 1374 call_for_symbol_and_aliases (symtab_node::set_section, 1375 const_cast<char *>(n->get_section ()), true); 1376 externally_visible = n->externally_visible; 1377 if (!DECL_RTL_SET_P (decl)) 1378 return; 1379 1380 /* Update rtl flags. */ 1381 make_decl_rtl (decl); 1382 1383 rtx rtl = DECL_RTL (decl); 1384 if (!MEM_P (rtl)) 1385 return; 1386 1387 rtx symbol = XEXP (rtl, 0); 1388 if (GET_CODE (symbol) != SYMBOL_REF) 1389 return; 1390 1391 SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl); 1392 } 1393 1394 /* Walk the alias chain to return the symbol NODE is alias of. 1395 If NODE is not an alias, return NODE. 1396 Assumes NODE is known to be alias. */ 1397 1398 symtab_node * 1399 symtab_node::ultimate_alias_target_1 (enum availability *availability, 1400 symtab_node *ref) 1401 { 1402 bool transparent_p = false; 1403 1404 /* To determine visibility of the target, we follow ELF semantic of aliases. 1405 Here alias is an alternative assembler name of a given definition. Its 1406 availability prevails the availability of its target (i.e. static alias of 1407 weak definition is available. 1408 1409 Transaparent alias is just alternative anme of a given symbol used within 1410 one compilation unit and is translated prior hitting the object file. It 1411 inherits the visibility of its target. 1412 Weakref is a different animal (and noweak definition is weak). 1413 1414 If we ever get into supporting targets with different semantics, a target 1415 hook will be needed here. */ 1416 1417 if (availability) 1418 { 1419 transparent_p = transparent_alias; 1420 if (!transparent_p) 1421 *availability = get_availability (ref); 1422 else 1423 *availability = AVAIL_NOT_AVAILABLE; 1424 } 1425 1426 symtab_node *node = this; 1427 while (node) 1428 { 1429 if (node->alias && node->analyzed) 1430 node = node->get_alias_target (); 1431 else 1432 { 1433 if (!availability || (!transparent_p && node->analyzed)) 1434 ; 1435 else if (node->analyzed && !node->transparent_alias) 1436 *availability = node->get_availability (ref); 1437 else 1438 *availability = AVAIL_NOT_AVAILABLE; 1439 return node; 1440 } 1441 if (node && availability && transparent_p 1442 && node->transparent_alias) 1443 { 1444 *availability = node->get_availability (ref); 1445 transparent_p = false; 1446 } 1447 } 1448 if (availability) 1449 *availability = AVAIL_NOT_AVAILABLE; 1450 return NULL; 1451 } 1452 1453 /* C++ FE sometimes change linkage flags after producing same body aliases. 1454 1455 FIXME: C++ produce implicit aliases for virtual functions and vtables that 1456 are obviously equivalent. The way it is doing so is however somewhat 1457 kludgy and interferes with the visibility code. As a result we need to 1458 copy the visibility from the target to get things right. */ 1459 1460 void 1461 symtab_node::fixup_same_cpp_alias_visibility (symtab_node *target) 1462 { 1463 if (is_a <cgraph_node *> (this)) 1464 { 1465 DECL_DECLARED_INLINE_P (decl) 1466 = DECL_DECLARED_INLINE_P (target->decl); 1467 DECL_DISREGARD_INLINE_LIMITS (decl) 1468 = DECL_DISREGARD_INLINE_LIMITS (target->decl); 1469 } 1470 /* FIXME: It is not really clear why those flags should not be copied for 1471 functions, too. */ 1472 else 1473 { 1474 DECL_WEAK (decl) = DECL_WEAK (target->decl); 1475 DECL_EXTERNAL (decl) = DECL_EXTERNAL (target->decl); 1476 DECL_VISIBILITY (decl) = DECL_VISIBILITY (target->decl); 1477 } 1478 if (TREE_PUBLIC (decl)) 1479 { 1480 tree group; 1481 1482 DECL_EXTERNAL (decl) = DECL_EXTERNAL (target->decl); 1483 DECL_COMDAT (decl) = DECL_COMDAT (target->decl); 1484 group = target->get_comdat_group (); 1485 set_comdat_group (group); 1486 if (group && !same_comdat_group) 1487 add_to_same_comdat_group (target); 1488 } 1489 externally_visible = target->externally_visible; 1490 } 1491 1492 /* Set section, do not recurse into aliases. 1493 When one wants to change section of a symbol and its aliases, 1494 use set_section. */ 1495 1496 void 1497 symtab_node::set_section_for_node (const char *section) 1498 { 1499 const char *current = get_section (); 1500 section_hash_entry **slot; 1501 1502 if (current == section 1503 || (current && section 1504 && !strcmp (current, section))) 1505 return; 1506 1507 if (current) 1508 { 1509 x_section->ref_count--; 1510 if (!x_section->ref_count) 1511 { 1512 hashval_t hash = htab_hash_string (x_section->name); 1513 slot = symtab->section_hash->find_slot_with_hash (x_section->name, 1514 hash, INSERT); 1515 ggc_free (x_section); 1516 symtab->section_hash->clear_slot (slot); 1517 } 1518 x_section = NULL; 1519 } 1520 if (!section) 1521 { 1522 implicit_section = false; 1523 return; 1524 } 1525 if (!symtab->section_hash) 1526 symtab->section_hash = hash_table<section_name_hasher>::create_ggc (10); 1527 slot = symtab->section_hash->find_slot_with_hash (section, 1528 htab_hash_string (section), 1529 INSERT); 1530 if (*slot) 1531 x_section = (section_hash_entry *)*slot; 1532 else 1533 { 1534 int len = strlen (section); 1535 *slot = x_section = ggc_cleared_alloc<section_hash_entry> (); 1536 x_section->name = ggc_vec_alloc<char> (len + 1); 1537 memcpy (x_section->name, section, len + 1); 1538 } 1539 x_section->ref_count++; 1540 } 1541 1542 /* Worker for set_section. */ 1543 1544 bool 1545 symtab_node::set_section (symtab_node *n, void *s) 1546 { 1547 n->set_section_for_node ((char *)s); 1548 return false; 1549 } 1550 1551 /* Set section of symbol and its aliases. */ 1552 1553 void 1554 symtab_node::set_section (const char *section) 1555 { 1556 gcc_assert (!this->alias || !this->analyzed); 1557 call_for_symbol_and_aliases 1558 (symtab_node::set_section, const_cast<char *>(section), true); 1559 } 1560 1561 /* Return the initialization priority. */ 1562 1563 priority_type 1564 symtab_node::get_init_priority () 1565 { 1566 if (!this->in_init_priority_hash) 1567 return DEFAULT_INIT_PRIORITY; 1568 1569 symbol_priority_map *h = symtab->init_priority_hash->get (this); 1570 return h ? h->init : DEFAULT_INIT_PRIORITY; 1571 } 1572 1573 /* Return the finalization priority. */ 1574 1575 priority_type 1576 cgraph_node::get_fini_priority () 1577 { 1578 if (!this->in_init_priority_hash) 1579 return DEFAULT_INIT_PRIORITY; 1580 symbol_priority_map *h = symtab->init_priority_hash->get (this); 1581 return h ? h->fini : DEFAULT_INIT_PRIORITY; 1582 } 1583 1584 /* Return the initialization and finalization priority information for 1585 DECL. If there is no previous priority information, a freshly 1586 allocated structure is returned. */ 1587 1588 symbol_priority_map * 1589 symtab_node::priority_info (void) 1590 { 1591 if (!symtab->init_priority_hash) 1592 symtab->init_priority_hash = hash_map<symtab_node *, symbol_priority_map>::create_ggc (13); 1593 1594 bool existed; 1595 symbol_priority_map *h 1596 = &symtab->init_priority_hash->get_or_insert (this, &existed); 1597 if (!existed) 1598 { 1599 h->init = DEFAULT_INIT_PRIORITY; 1600 h->fini = DEFAULT_INIT_PRIORITY; 1601 in_init_priority_hash = true; 1602 } 1603 1604 return h; 1605 } 1606 1607 /* Set initialization priority to PRIORITY. */ 1608 1609 void 1610 symtab_node::set_init_priority (priority_type priority) 1611 { 1612 symbol_priority_map *h; 1613 1614 if (is_a <cgraph_node *> (this)) 1615 gcc_assert (DECL_STATIC_CONSTRUCTOR (this->decl)); 1616 1617 if (priority == DEFAULT_INIT_PRIORITY) 1618 { 1619 gcc_assert (get_init_priority() == priority); 1620 return; 1621 } 1622 h = priority_info (); 1623 h->init = priority; 1624 } 1625 1626 /* Set fialization priority to PRIORITY. */ 1627 1628 void 1629 cgraph_node::set_fini_priority (priority_type priority) 1630 { 1631 symbol_priority_map *h; 1632 1633 gcc_assert (DECL_STATIC_DESTRUCTOR (this->decl)); 1634 1635 if (priority == DEFAULT_INIT_PRIORITY) 1636 { 1637 gcc_assert (get_fini_priority() == priority); 1638 return; 1639 } 1640 h = priority_info (); 1641 h->fini = priority; 1642 } 1643 1644 /* Worker for symtab_resolve_alias. */ 1645 1646 bool 1647 symtab_node::set_implicit_section (symtab_node *n, 1648 void *data ATTRIBUTE_UNUSED) 1649 { 1650 n->implicit_section = true; 1651 return false; 1652 } 1653 1654 /* Add reference recording that symtab node is alias of TARGET. 1655 The function can fail in the case of aliasing cycles; in this case 1656 it returns false. */ 1657 1658 bool 1659 symtab_node::resolve_alias (symtab_node *target, bool transparent) 1660 { 1661 symtab_node *n; 1662 1663 gcc_assert (!analyzed && !vec_safe_length (ref_list.references)); 1664 1665 /* Never let cycles to creep into the symbol table alias references; 1666 those will make alias walkers to be infinite. */ 1667 for (n = target; n && n->alias; 1668 n = n->analyzed ? n->get_alias_target () : NULL) 1669 if (n == this) 1670 { 1671 if (is_a <cgraph_node *> (this)) 1672 error ("function %q+D part of alias cycle", decl); 1673 else if (is_a <varpool_node *> (this)) 1674 error ("variable %q+D part of alias cycle", decl); 1675 else 1676 gcc_unreachable (); 1677 alias = false; 1678 return false; 1679 } 1680 1681 /* "analyze" the node - i.e. mark the reference. */ 1682 definition = true; 1683 alias = true; 1684 analyzed = true; 1685 transparent |= transparent_alias; 1686 transparent_alias = transparent; 1687 if (transparent) 1688 while (target->transparent_alias && target->analyzed) 1689 target = target->get_alias_target (); 1690 create_reference (target, IPA_REF_ALIAS, NULL); 1691 1692 /* Add alias into the comdat group of its target unless it is already there. */ 1693 if (same_comdat_group) 1694 remove_from_same_comdat_group (); 1695 set_comdat_group (NULL); 1696 if (target->get_comdat_group ()) 1697 add_to_same_comdat_group (target); 1698 1699 if ((get_section () != target->get_section () 1700 || target->get_comdat_group ()) && get_section () && !implicit_section) 1701 { 1702 error ("section of alias %q+D must match section of its target", decl); 1703 } 1704 call_for_symbol_and_aliases (symtab_node::set_section, 1705 const_cast<char *>(target->get_section ()), true); 1706 if (target->implicit_section) 1707 call_for_symbol_and_aliases (set_implicit_section, NULL, true); 1708 1709 /* Alias targets become redundant after alias is resolved into an reference. 1710 We do not want to keep it around or we would have to mind updating them 1711 when renaming symbols. */ 1712 alias_target = NULL; 1713 1714 if (!transparent && cpp_implicit_alias && symtab->state >= CONSTRUCTION) 1715 fixup_same_cpp_alias_visibility (target); 1716 1717 /* If alias has address taken, so does the target. */ 1718 if (address_taken) 1719 target->ultimate_alias_target ()->address_taken = true; 1720 1721 /* All non-transparent aliases of THIS are now in fact aliases of TARGET. 1722 If alias is transparent, also all transparent aliases of THIS are now 1723 aliases of TARGET. 1724 Also merge same comdat group lists. */ 1725 ipa_ref *ref; 1726 for (unsigned i = 0; iterate_direct_aliases (i, ref);) 1727 { 1728 struct symtab_node *alias_alias = ref->referring; 1729 if (alias_alias->get_comdat_group ()) 1730 { 1731 alias_alias->remove_from_same_comdat_group (); 1732 alias_alias->set_comdat_group (NULL); 1733 if (target->get_comdat_group ()) 1734 alias_alias->add_to_same_comdat_group (target); 1735 } 1736 if (!alias_alias->transparent_alias || transparent) 1737 { 1738 alias_alias->remove_all_references (); 1739 alias_alias->create_reference (target, IPA_REF_ALIAS, NULL); 1740 } 1741 else i++; 1742 } 1743 return true; 1744 } 1745 1746 /* Worker searching noninterposable alias. */ 1747 1748 bool 1749 symtab_node::noninterposable_alias (symtab_node *node, void *data) 1750 { 1751 if (!node->transparent_alias && decl_binds_to_current_def_p (node->decl)) 1752 { 1753 symtab_node *fn = node->ultimate_alias_target (); 1754 1755 /* Ensure that the alias is well formed this may not be the case 1756 of user defined aliases and currently it is not always the case 1757 of C++ same body aliases (that is a bug). */ 1758 if (TREE_TYPE (node->decl) != TREE_TYPE (fn->decl) 1759 || DECL_CONTEXT (node->decl) != DECL_CONTEXT (fn->decl) 1760 || (TREE_CODE (node->decl) == FUNCTION_DECL 1761 && flags_from_decl_or_type (node->decl) 1762 != flags_from_decl_or_type (fn->decl)) 1763 || DECL_ATTRIBUTES (node->decl) != DECL_ATTRIBUTES (fn->decl)) 1764 return false; 1765 *(symtab_node **)data = node; 1766 return true; 1767 } 1768 return false; 1769 } 1770 1771 /* If node cannot be overwriten by static or dynamic linker to point to 1772 different definition, return NODE. Otherwise look for alias with such 1773 property and if none exists, introduce new one. */ 1774 1775 symtab_node * 1776 symtab_node::noninterposable_alias (void) 1777 { 1778 tree new_decl; 1779 symtab_node *new_node = NULL; 1780 1781 /* First try to look up existing alias or base object 1782 (if that is already non-overwritable). */ 1783 symtab_node *node = ultimate_alias_target (); 1784 gcc_assert (!node->alias && !node->weakref); 1785 node->call_for_symbol_and_aliases (symtab_node::noninterposable_alias, 1786 (void *)&new_node, true); 1787 if (new_node) 1788 return new_node; 1789 1790 /* If aliases aren't supported by the assembler, fail. */ 1791 if (!TARGET_SUPPORTS_ALIASES) 1792 return NULL; 1793 1794 /* Otherwise create a new one. */ 1795 new_decl = copy_node (node->decl); 1796 DECL_DLLIMPORT_P (new_decl) = 0; 1797 DECL_NAME (new_decl) = clone_function_name (node->decl, "localalias"); 1798 if (TREE_CODE (new_decl) == FUNCTION_DECL) 1799 DECL_STRUCT_FUNCTION (new_decl) = NULL; 1800 DECL_INITIAL (new_decl) = NULL; 1801 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl)); 1802 SET_DECL_RTL (new_decl, NULL); 1803 1804 /* Update the properties. */ 1805 DECL_EXTERNAL (new_decl) = 0; 1806 TREE_PUBLIC (new_decl) = 0; 1807 DECL_COMDAT (new_decl) = 0; 1808 DECL_WEAK (new_decl) = 0; 1809 1810 /* Since the aliases can be added to vtables, keep DECL_VIRTUAL flag. */ 1811 DECL_VIRTUAL_P (new_decl) = DECL_VIRTUAL_P (node->decl); 1812 if (TREE_CODE (new_decl) == FUNCTION_DECL) 1813 { 1814 DECL_STATIC_CONSTRUCTOR (new_decl) = 0; 1815 DECL_STATIC_DESTRUCTOR (new_decl) = 0; 1816 new_node = cgraph_node::create_alias (new_decl, node->decl); 1817 } 1818 else 1819 { 1820 TREE_READONLY (new_decl) = TREE_READONLY (node->decl); 1821 DECL_INITIAL (new_decl) = error_mark_node; 1822 new_node = varpool_node::create_alias (new_decl, node->decl); 1823 } 1824 new_node->resolve_alias (node); 1825 gcc_assert (decl_binds_to_current_def_p (new_decl) 1826 && targetm.binds_local_p (new_decl)); 1827 return new_node; 1828 } 1829 1830 /* Return true if symtab node and TARGET represents 1831 semantically equivalent symbols. */ 1832 1833 bool 1834 symtab_node::semantically_equivalent_p (symtab_node *target) 1835 { 1836 enum availability avail; 1837 symtab_node *ba; 1838 symtab_node *bb; 1839 1840 /* Equivalent functions are equivalent. */ 1841 if (decl == target->decl) 1842 return true; 1843 1844 /* If symbol is not overwritable by different implementation, 1845 walk to the base object it defines. */ 1846 ba = ultimate_alias_target (&avail); 1847 if (avail >= AVAIL_AVAILABLE) 1848 { 1849 if (target == ba) 1850 return true; 1851 } 1852 else 1853 ba = this; 1854 bb = target->ultimate_alias_target (&avail); 1855 if (avail >= AVAIL_AVAILABLE) 1856 { 1857 if (this == bb) 1858 return true; 1859 } 1860 else 1861 bb = target; 1862 return bb == ba; 1863 } 1864 1865 /* Classify symbol symtab node for partitioning. */ 1866 1867 enum symbol_partitioning_class 1868 symtab_node::get_partitioning_class (void) 1869 { 1870 /* Inline clones are always duplicated. 1871 This include external delcarations. */ 1872 cgraph_node *cnode = dyn_cast <cgraph_node *> (this); 1873 1874 if (DECL_ABSTRACT_P (decl)) 1875 return SYMBOL_EXTERNAL; 1876 1877 if (cnode && cnode->global.inlined_to) 1878 return SYMBOL_DUPLICATE; 1879 1880 /* Transparent aliases are always duplicated. */ 1881 if (transparent_alias) 1882 return definition ? SYMBOL_DUPLICATE : SYMBOL_EXTERNAL; 1883 1884 /* External declarations are external. */ 1885 if (DECL_EXTERNAL (decl)) 1886 return SYMBOL_EXTERNAL; 1887 1888 if (varpool_node *vnode = dyn_cast <varpool_node *> (this)) 1889 { 1890 if (alias && definition && !ultimate_alias_target ()->definition) 1891 return SYMBOL_EXTERNAL; 1892 /* Constant pool references use local symbol names that cannot 1893 be promoted global. We should never put into a constant pool 1894 objects that cannot be duplicated across partitions. */ 1895 if (DECL_IN_CONSTANT_POOL (decl)) 1896 return SYMBOL_DUPLICATE; 1897 if (DECL_HARD_REGISTER (decl)) 1898 return SYMBOL_DUPLICATE; 1899 gcc_checking_assert (vnode->definition); 1900 } 1901 /* Functions that are cloned may stay in callgraph even if they are unused. 1902 Handle them as external; compute_ltrans_boundary take care to make 1903 proper things to happen (i.e. to make them appear in the boundary but 1904 with body streamed, so clone can me materialized). */ 1905 else if (!dyn_cast <cgraph_node *> (this)->function_symbol ()->definition) 1906 return SYMBOL_EXTERNAL; 1907 1908 /* Linker discardable symbols are duplicated to every use unless they are 1909 keyed. */ 1910 if (DECL_ONE_ONLY (decl) 1911 && !force_output 1912 && !forced_by_abi 1913 && !used_from_object_file_p ()) 1914 return SYMBOL_DUPLICATE; 1915 1916 return SYMBOL_PARTITION; 1917 } 1918 1919 /* Return true when symbol is known to be non-zero. */ 1920 1921 bool 1922 symtab_node::nonzero_address () 1923 { 1924 /* Weakrefs may be NULL when their target is not defined. */ 1925 if (alias && weakref) 1926 { 1927 if (analyzed) 1928 { 1929 symtab_node *target = ultimate_alias_target (); 1930 1931 if (target->alias && target->weakref) 1932 return false; 1933 /* We cannot recurse to target::nonzero. It is possible that the 1934 target is used only via the alias. 1935 We may walk references and look for strong use, but we do not know 1936 if this strong use will survive to final binary, so be 1937 conservative here. 1938 ??? Maybe we could do the lookup during late optimization that 1939 could be useful to eliminate the NULL pointer checks in LTO 1940 programs. */ 1941 if (target->definition && !DECL_EXTERNAL (target->decl)) 1942 return true; 1943 if (target->resolution != LDPR_UNKNOWN 1944 && target->resolution != LDPR_UNDEF 1945 && !target->can_be_discarded_p () 1946 && flag_delete_null_pointer_checks) 1947 return true; 1948 return false; 1949 } 1950 else 1951 return false; 1952 } 1953 1954 /* With !flag_delete_null_pointer_checks we assume that symbols may 1955 bind to NULL. This is on by default on embedded targets only. 1956 1957 Otherwise all non-WEAK symbols must be defined and thus non-NULL or 1958 linking fails. Important case of WEAK we want to do well are comdats, 1959 which also must be defined somewhere. 1960 1961 When parsing, beware the cases when WEAK attribute is added later. */ 1962 if ((!DECL_WEAK (decl) || DECL_COMDAT (decl)) 1963 && flag_delete_null_pointer_checks) 1964 { 1965 refuse_visibility_changes = true; 1966 return true; 1967 } 1968 1969 /* If target is defined and not extern, we know it will be 1970 output and thus it will bind to non-NULL. 1971 Play safe for flag_delete_null_pointer_checks where weak definition may 1972 be re-defined by NULL. */ 1973 if (definition && !DECL_EXTERNAL (decl) 1974 && (flag_delete_null_pointer_checks || !DECL_WEAK (decl))) 1975 { 1976 if (!DECL_WEAK (decl)) 1977 refuse_visibility_changes = true; 1978 return true; 1979 } 1980 1981 /* As the last resort, check the resolution info. */ 1982 if (resolution != LDPR_UNKNOWN 1983 && resolution != LDPR_UNDEF 1984 && !can_be_discarded_p () 1985 && flag_delete_null_pointer_checks) 1986 return true; 1987 return false; 1988 } 1989 1990 /* Return 0 if symbol is known to have different address than S2, 1991 Return 1 if symbol is known to have same address as S2, 1992 return -1 otherwise. 1993 1994 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS 1995 and S2 is going to be accessed. This eliminates the situations when 1996 either THIS or S2 is NULL and is seful for comparing bases when deciding 1997 about memory aliasing. */ 1998 int 1999 symtab_node::equal_address_to (symtab_node *s2, bool memory_accessed) 2000 { 2001 enum availability avail1, avail2; 2002 2003 /* A Shortcut: equivalent symbols are always equivalent. */ 2004 if (this == s2) 2005 return 1; 2006 2007 /* Unwind transparent aliases first; those are always equal to their 2008 target. */ 2009 if (this->transparent_alias && this->analyzed) 2010 return this->get_alias_target ()->equal_address_to (s2); 2011 while (s2->transparent_alias && s2->analyzed) 2012 s2 = s2->get_alias_target(); 2013 2014 if (this == s2) 2015 return 1; 2016 2017 /* For non-interposable aliases, lookup and compare their actual definitions. 2018 Also check if the symbol needs to bind to given definition. */ 2019 symtab_node *rs1 = ultimate_alias_target (&avail1); 2020 symtab_node *rs2 = s2->ultimate_alias_target (&avail2); 2021 bool binds_local1 = rs1->analyzed && decl_binds_to_current_def_p (this->decl); 2022 bool binds_local2 = rs2->analyzed && decl_binds_to_current_def_p (s2->decl); 2023 bool really_binds_local1 = binds_local1; 2024 bool really_binds_local2 = binds_local2; 2025 2026 /* Addresses of vtables and virtual functions cannot be used by user 2027 code and are used only within speculation. In this case we may make 2028 symbol equivalent to its alias even if interposition may break this 2029 rule. Doing so will allow us to turn speculative inlining into 2030 non-speculative more agressively. */ 2031 if (DECL_VIRTUAL_P (this->decl) && avail1 >= AVAIL_AVAILABLE) 2032 binds_local1 = true; 2033 if (DECL_VIRTUAL_P (s2->decl) && avail2 >= AVAIL_AVAILABLE) 2034 binds_local2 = true; 2035 2036 /* If both definitions are available we know that even if they are bound 2037 to other unit they must be defined same way and therefore we can use 2038 equivalence test. */ 2039 if (rs1 != rs2 && avail1 >= AVAIL_AVAILABLE && avail2 >= AVAIL_AVAILABLE) 2040 binds_local1 = binds_local2 = true; 2041 2042 if (binds_local1 && binds_local2 && rs1 == rs2) 2043 { 2044 /* We made use of the fact that alias is not weak. */ 2045 if (rs1 != this) 2046 refuse_visibility_changes = true; 2047 if (rs2 != s2) 2048 s2->refuse_visibility_changes = true; 2049 return 1; 2050 } 2051 2052 /* If both symbols may resolve to NULL, we cannot really prove them 2053 different. */ 2054 if (!memory_accessed && !nonzero_address () && !s2->nonzero_address ()) 2055 return -1; 2056 2057 /* Except for NULL, functions and variables never overlap. */ 2058 if (TREE_CODE (decl) != TREE_CODE (s2->decl)) 2059 return 0; 2060 2061 /* If one of the symbols is unresolved alias, punt. */ 2062 if (rs1->alias || rs2->alias) 2063 return -1; 2064 2065 /* If we have a non-interposale definition of at least one of the symbols 2066 and the other symbol is different, we know other unit cannot interpose 2067 it to the first symbol; all aliases of the definition needs to be 2068 present in the current unit. */ 2069 if (((really_binds_local1 || really_binds_local2) 2070 /* If we have both definitions and they are different, we know they 2071 will be different even in units they binds to. */ 2072 || (binds_local1 && binds_local2)) 2073 && rs1 != rs2) 2074 { 2075 /* We make use of the fact that one symbol is not alias of the other 2076 and that the definition is non-interposable. */ 2077 refuse_visibility_changes = true; 2078 s2->refuse_visibility_changes = true; 2079 rs1->refuse_visibility_changes = true; 2080 rs2->refuse_visibility_changes = true; 2081 return 0; 2082 } 2083 2084 /* TODO: Alias oracle basically assume that addresses of global variables 2085 are different unless they are declared as alias of one to another while 2086 the code folding comparsions doesn't. 2087 We probably should be consistent and use this fact here, too, but for 2088 the moment return false only when we are called from the alias oracle. */ 2089 2090 return memory_accessed && rs1 != rs2 ? 0 : -1; 2091 } 2092 2093 /* Worker for call_for_symbol_and_aliases. */ 2094 2095 bool 2096 symtab_node::call_for_symbol_and_aliases_1 (bool (*callback) (symtab_node *, 2097 void *), 2098 void *data, 2099 bool include_overwritable) 2100 { 2101 ipa_ref *ref; 2102 FOR_EACH_ALIAS (this, ref) 2103 { 2104 symtab_node *alias = ref->referring; 2105 if (include_overwritable 2106 || alias->get_availability () > AVAIL_INTERPOSABLE) 2107 if (alias->call_for_symbol_and_aliases (callback, data, 2108 include_overwritable)) 2109 return true; 2110 } 2111 return false; 2112 } 2113 2114 /* Return true if address of N is possibly compared. */ 2115 2116 static bool 2117 address_matters_1 (symtab_node *n, void *) 2118 { 2119 struct ipa_ref *ref; 2120 2121 if (!n->address_can_be_compared_p ()) 2122 return false; 2123 if (n->externally_visible || n->force_output) 2124 return true; 2125 2126 for (unsigned int i = 0; n->iterate_referring (i, ref); i++) 2127 if (ref->address_matters_p ()) 2128 return true; 2129 return false; 2130 } 2131 2132 /* Return true if symbol's address may possibly be compared to other 2133 symbol's address. */ 2134 2135 bool 2136 symtab_node::address_matters_p () 2137 { 2138 gcc_assert (!alias); 2139 return call_for_symbol_and_aliases (address_matters_1, NULL, true); 2140 } 2141 2142 /* Return true if symbol's alignment may be increased. */ 2143 2144 bool 2145 symtab_node::can_increase_alignment_p (void) 2146 { 2147 symtab_node *target = ultimate_alias_target (); 2148 2149 /* For now support only variables. */ 2150 if (!VAR_P (decl)) 2151 return false; 2152 2153 /* With -fno-toplevel-reorder we may have already output the constant. */ 2154 if (TREE_ASM_WRITTEN (target->decl)) 2155 return false; 2156 2157 /* If target is already placed in an anchor, we cannot touch its 2158 alignment. */ 2159 if (DECL_RTL_SET_P (target->decl) 2160 && MEM_P (DECL_RTL (target->decl)) 2161 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (DECL_RTL (target->decl), 0))) 2162 return false; 2163 2164 /* Constant pool entries may be shared. */ 2165 if (DECL_IN_CONSTANT_POOL (target->decl)) 2166 return false; 2167 2168 /* We cannot change alignment of symbols that may bind to symbols 2169 in other translation unit that may contain a definition with lower 2170 alignment. */ 2171 if (!decl_binds_to_current_def_p (decl)) 2172 return false; 2173 2174 /* When compiling partition, be sure the symbol is not output by other 2175 partition. */ 2176 if (flag_ltrans 2177 && (target->in_other_partition 2178 || target->get_partitioning_class () == SYMBOL_DUPLICATE)) 2179 return false; 2180 2181 /* Do not override the alignment as specified by the ABI when the used 2182 attribute is set. */ 2183 if (DECL_PRESERVE_P (decl) || DECL_PRESERVE_P (target->decl)) 2184 return false; 2185 2186 /* Do not override explicit alignment set by the user when an explicit 2187 section name is also used. This is a common idiom used by many 2188 software projects. */ 2189 if (DECL_SECTION_NAME (target->decl) != NULL && !target->implicit_section) 2190 return false; 2191 2192 return true; 2193 } 2194 2195 /* Worker for symtab_node::increase_alignment. */ 2196 2197 static bool 2198 increase_alignment_1 (symtab_node *n, void *v) 2199 { 2200 unsigned int align = (size_t)v; 2201 if (DECL_ALIGN (n->decl) < align 2202 && n->can_increase_alignment_p ()) 2203 { 2204 SET_DECL_ALIGN (n->decl, align); 2205 DECL_USER_ALIGN (n->decl) = 1; 2206 } 2207 return false; 2208 } 2209 2210 /* Increase alignment of THIS to ALIGN. */ 2211 2212 void 2213 symtab_node::increase_alignment (unsigned int align) 2214 { 2215 gcc_assert (can_increase_alignment_p () && align <= MAX_OFILE_ALIGNMENT); 2216 ultimate_alias_target()->call_for_symbol_and_aliases (increase_alignment_1, 2217 (void *)(size_t) align, 2218 true); 2219 gcc_assert (DECL_ALIGN (decl) >= align); 2220 } 2221 2222 /* Helper for symtab_node::definition_alignment. */ 2223 2224 static bool 2225 get_alignment_1 (symtab_node *n, void *v) 2226 { 2227 *((unsigned int *)v) = MAX (*((unsigned int *)v), DECL_ALIGN (n->decl)); 2228 return false; 2229 } 2230 2231 /* Return desired alignment of the definition. This is NOT alignment useful 2232 to access THIS, because THIS may be interposable and DECL_ALIGN should 2233 be used instead. It however must be guaranteed when output definition 2234 of THIS. */ 2235 2236 unsigned int 2237 symtab_node::definition_alignment () 2238 { 2239 unsigned int align = 0; 2240 gcc_assert (!alias); 2241 call_for_symbol_and_aliases (get_alignment_1, &align, true); 2242 return align; 2243 } 2244 2245 /* Return symbol used to separate symbol name from suffix. */ 2246 2247 char 2248 symbol_table::symbol_suffix_separator () 2249 { 2250 #ifndef NO_DOT_IN_LABEL 2251 return '.'; 2252 #elif !defined NO_DOLLAR_IN_LABEL 2253 return '$'; 2254 #else 2255 return '_'; 2256 #endif 2257 } 2258 2259 /* Return true when references to this symbol from REF must bind to current 2260 definition in final executable. */ 2261 2262 bool 2263 symtab_node::binds_to_current_def_p (symtab_node *ref) 2264 { 2265 if (!definition) 2266 return false; 2267 if (transparent_alias) 2268 return definition 2269 && get_alias_target()->binds_to_current_def_p (ref); 2270 cgraph_node *cnode = dyn_cast <cgraph_node *> (this); 2271 if (cnode && cnode->ifunc_resolver) 2272 return false; 2273 if (decl_binds_to_current_def_p (decl)) 2274 return true; 2275 2276 /* Inline clones always binds locally. */ 2277 if (cnode && cnode->global.inlined_to) 2278 return true; 2279 2280 if (DECL_EXTERNAL (decl)) 2281 return false; 2282 2283 gcc_assert (externally_visible); 2284 2285 if (ref) 2286 { 2287 cgraph_node *cref = dyn_cast <cgraph_node *> (ref); 2288 if (cref) 2289 ref = cref->global.inlined_to; 2290 } 2291 2292 /* If this is a reference from symbol itself and there are no aliases, we 2293 may be sure that the symbol was not interposed by something else because 2294 the symbol itself would be unreachable otherwise. This is important 2295 to optimize recursive functions well. 2296 2297 This assumption may be broken by inlining: if symbol is interposable 2298 but the body is available (i.e. declared inline), inliner may make 2299 the body reachable even with interposition. */ 2300 if (this == ref && !has_aliases_p () 2301 && (!cnode 2302 || symtab->state >= IPA_SSA_AFTER_INLINING 2303 || get_availability () >= AVAIL_INTERPOSABLE)) 2304 return true; 2305 2306 2307 /* References within one comdat group are always bound in a group. */ 2308 if (ref 2309 && symtab->state >= IPA_SSA_AFTER_INLINING 2310 && get_comdat_group () 2311 && get_comdat_group () == ref->get_comdat_group ()) 2312 return true; 2313 2314 return false; 2315 } 2316 2317 /* Return true if symbol should be output to the symbol table. */ 2318 2319 bool 2320 symtab_node::output_to_lto_symbol_table_p (void) 2321 { 2322 /* Only externally visible symbols matter. */ 2323 if (!TREE_PUBLIC (decl)) 2324 return false; 2325 if (!real_symbol_p ()) 2326 return false; 2327 /* FIXME: variables probably should not be considered as real symbols at 2328 first place. */ 2329 if (VAR_P (decl) && DECL_HARD_REGISTER (decl)) 2330 return false; 2331 if (TREE_CODE (decl) == FUNCTION_DECL && !definition 2332 && fndecl_built_in_p (decl)) 2333 { 2334 /* Builtins like those for most math functions have actual implementations 2335 in libraries so make sure to output references into the symbol table to 2336 make those libraries referenced. Note this is incomplete handling for 2337 now and only covers math functions. */ 2338 if (builtin_with_linkage_p (decl)) 2339 return true; 2340 else 2341 return false; 2342 } 2343 2344 /* We have real symbol that should be in symbol table. However try to trim 2345 down the refernces to libraries bit more because linker will otherwise 2346 bring unnecesary object files into the final link. 2347 FIXME: The following checks can easily be confused i.e. by self recursive 2348 function or self-referring variable. */ 2349 2350 /* We keep external functions in symtab for sake of inlining 2351 and devirtualization. We do not want to see them in symbol table as 2352 references unless they are really used. */ 2353 cgraph_node *cnode = dyn_cast <cgraph_node *> (this); 2354 if (cnode && (!definition || DECL_EXTERNAL (decl)) 2355 && cnode->callers) 2356 return true; 2357 2358 /* Ignore all references from external vars initializers - they are not really 2359 part of the compilation unit until they are used by folding. Some symbols, 2360 like references to external construction vtables cannot be referred to at 2361 all. We decide this at can_refer_decl_in_current_unit_p. */ 2362 if (!definition || DECL_EXTERNAL (decl)) 2363 { 2364 int i; 2365 struct ipa_ref *ref; 2366 for (i = 0; iterate_referring (i, ref); i++) 2367 { 2368 if (ref->use == IPA_REF_ALIAS) 2369 continue; 2370 if (is_a <cgraph_node *> (ref->referring)) 2371 return true; 2372 if (!DECL_EXTERNAL (ref->referring->decl)) 2373 return true; 2374 } 2375 return false; 2376 } 2377 return true; 2378 } 2379