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