1/* Callgraph handling code. 2 Copyright (C) 2003-2020 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 "backend.h" 25#include "target.h" 26#include "tree.h" 27#include "gimple.h" 28#include "timevar.h" 29#include "cgraph.h" 30#include "lto-streamer.h" 31#include "varasm.h" 32#include "debug.h" 33#include "output.h" 34#include "omp-offload.h" 35#include "context.h" 36#include "stringpool.h" 37#include "attribs.h" 38 39const char * const tls_model_names[]={"none", "emulated", 40 "global-dynamic", "local-dynamic", 41 "initial-exec", "local-exec"}; 42 43/* List of hooks triggered on varpool_node events. */ 44struct varpool_node_hook_list { 45 varpool_node_hook hook; 46 void *data; 47 struct varpool_node_hook_list *next; 48}; 49 50/* Register HOOK to be called with DATA on each removed node. */ 51varpool_node_hook_list * 52symbol_table::add_varpool_removal_hook (varpool_node_hook hook, void *data) 53{ 54 varpool_node_hook_list *entry; 55 varpool_node_hook_list **ptr = &m_first_varpool_removal_hook; 56 57 entry = (varpool_node_hook_list *) xmalloc (sizeof (*entry)); 58 entry->hook = hook; 59 entry->data = data; 60 entry->next = NULL; 61 while (*ptr) 62 ptr = &(*ptr)->next; 63 *ptr = entry; 64 return entry; 65} 66 67/* Remove ENTRY from the list of hooks called on removing nodes. */ 68void 69symbol_table::remove_varpool_removal_hook (varpool_node_hook_list *entry) 70{ 71 varpool_node_hook_list **ptr = &m_first_varpool_removal_hook; 72 73 while (*ptr != entry) 74 ptr = &(*ptr)->next; 75 *ptr = entry->next; 76 free (entry); 77} 78 79/* Call all node removal hooks. */ 80void 81symbol_table::call_varpool_removal_hooks (varpool_node *node) 82{ 83 varpool_node_hook_list *entry = m_first_varpool_removal_hook; 84 while (entry) 85 { 86 entry->hook (node, entry->data); 87 entry = entry->next; 88 } 89} 90 91/* Register HOOK to be called with DATA on each inserted node. */ 92varpool_node_hook_list * 93symbol_table::add_varpool_insertion_hook (varpool_node_hook hook, void *data) 94{ 95 varpool_node_hook_list *entry; 96 varpool_node_hook_list **ptr = &m_first_varpool_insertion_hook; 97 98 entry = (varpool_node_hook_list *) xmalloc (sizeof (*entry)); 99 entry->hook = hook; 100 entry->data = data; 101 entry->next = NULL; 102 while (*ptr) 103 ptr = &(*ptr)->next; 104 *ptr = entry; 105 return entry; 106} 107 108/* Remove ENTRY from the list of hooks called on inserted nodes. */ 109void 110symbol_table::remove_varpool_insertion_hook (varpool_node_hook_list *entry) 111{ 112 varpool_node_hook_list **ptr = &m_first_varpool_insertion_hook; 113 114 while (*ptr != entry) 115 ptr = &(*ptr)->next; 116 *ptr = entry->next; 117 free (entry); 118} 119 120/* Call all node insertion hooks. */ 121void 122symbol_table::call_varpool_insertion_hooks (varpool_node *node) 123{ 124 varpool_node_hook_list *entry = m_first_varpool_insertion_hook; 125 while (entry) 126 { 127 entry->hook (node, entry->data); 128 entry = entry->next; 129 } 130} 131 132/* Allocate new callgraph node and insert it into basic data structures. */ 133 134varpool_node * 135varpool_node::create_empty (void) 136{ 137 return new (ggc_alloc<varpool_node> ()) varpool_node (); 138} 139 140/* Return varpool node assigned to DECL. Create new one when needed. */ 141varpool_node * 142varpool_node::get_create (tree decl) 143{ 144 varpool_node *node = varpool_node::get (decl); 145 gcc_checking_assert (VAR_P (decl)); 146 if (node) 147 return node; 148 149 node = varpool_node::create_empty (); 150 node->decl = decl; 151 152 if ((flag_openacc || flag_openmp) 153 && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl))) 154 { 155 node->offloadable = 1; 156 if (ENABLE_OFFLOADING && !DECL_EXTERNAL (decl)) 157 { 158 g->have_offload = true; 159 if (!in_lto_p) 160 vec_safe_push (offload_vars, decl); 161 } 162 } 163 164 node->register_symbol (); 165 return node; 166} 167 168/* Remove variable from symbol table. */ 169 170void 171varpool_node::remove (void) 172{ 173 symtab->call_varpool_removal_hooks (this); 174 if (lto_file_data) 175 { 176 lto_free_function_in_decl_state_for_node (this); 177 lto_file_data = NULL; 178 } 179 180 /* When streaming we can have multiple nodes associated with decl. */ 181 if (symtab->state == LTO_STREAMING) 182 ; 183 /* Keep constructor when it may be used for folding. We remove 184 references to external variables before final compilation. */ 185 else if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node 186 && !ctor_useable_for_folding_p ()) 187 remove_initializer (); 188 189 unregister (); 190 ggc_free (this); 191} 192 193/* Remove node initializer when it is no longer needed. */ 194void 195varpool_node::remove_initializer (void) 196{ 197 if (DECL_INITIAL (decl) 198 && !DECL_IN_CONSTANT_POOL (decl) 199 /* Keep vtables for BINFO folding. */ 200 && !DECL_VIRTUAL_P (decl) 201 /* FIXME: http://gcc.gnu.org/PR55395 */ 202 && debug_info_level == DINFO_LEVEL_NONE 203 /* When doing declaration merging we have duplicate 204 entries for given decl. Do not attempt to remove 205 the bodies, or we will end up removing 206 wrong one. */ 207 && symtab->state != LTO_STREAMING) 208 DECL_INITIAL (decl) = error_mark_node; 209} 210 211/* Dump given varpool node to F. */ 212void 213varpool_node::dump (FILE *f) 214{ 215 dump_base (f); 216 fprintf (f, " Availability: %s\n", 217 symtab->function_flags_ready 218 ? cgraph_availability_names[get_availability ()] 219 : "not-ready"); 220 fprintf (f, " Varpool flags:"); 221 if (DECL_INITIAL (decl)) 222 fprintf (f, " initialized"); 223 if (output) 224 fprintf (f, " output"); 225 if (used_by_single_function) 226 fprintf (f, " used-by-single-function"); 227 if (TREE_READONLY (decl)) 228 fprintf (f, " read-only"); 229 if (ctor_useable_for_folding_p ()) 230 fprintf (f, " const-value-known"); 231 if (writeonly) 232 fprintf (f, " write-only"); 233 if (tls_model) 234 fprintf (f, " tls-%s", tls_model_names [tls_model]); 235 fprintf (f, "\n"); 236} 237 238 239/* Dump given varpool node to stderr. */ 240void varpool_node::debug (void) 241{ 242 varpool_node::dump (stderr); 243} 244 245/* Dump the variable pool to F. */ 246void 247varpool_node::dump_varpool (FILE *f) 248{ 249 varpool_node *node; 250 251 fprintf (f, "variable pool:\n\n"); 252 FOR_EACH_VARIABLE (node) 253 node->dump (f); 254} 255 256/* Dump the variable pool to stderr. */ 257 258DEBUG_FUNCTION void 259varpool_node::debug_varpool (void) 260{ 261 dump_varpool (stderr); 262} 263 264/* Given an assembler name, lookup node. */ 265varpool_node * 266varpool_node::get_for_asmname (tree asmname) 267{ 268 if (symtab_node *node = symtab_node::get_for_asmname (asmname)) 269 return dyn_cast <varpool_node *> (node); 270 else 271 return NULL; 272} 273 274/* When doing LTO, read variable's constructor from disk if 275 it is not already present. */ 276 277tree 278varpool_node::get_constructor (void) 279{ 280 lto_file_decl_data *file_data; 281 const char *data, *name; 282 size_t len; 283 284 if (DECL_INITIAL (decl) != error_mark_node 285 || !in_lto_p 286 || !lto_file_data) 287 return DECL_INITIAL (decl); 288 289 timevar_push (TV_IPA_LTO_CTORS_IN); 290 291 file_data = lto_file_data; 292 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 293 294 /* We may have renamed the declaration, e.g., a static function. */ 295 name = lto_get_decl_name_mapping (file_data, name); 296 struct lto_in_decl_state *decl_state 297 = lto_get_function_in_decl_state (file_data, decl); 298 299 data = lto_get_section_data (file_data, LTO_section_function_body, 300 name, order - file_data->order_base, 301 &len, decl_state->compressed); 302 if (!data) 303 fatal_error (input_location, "%s: section %s.%d is missing", 304 file_data->file_name, 305 name, order - file_data->order_base); 306 307 if (!quiet_flag) 308 fprintf (stderr, " in:%s", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); 309 lto_input_variable_constructor (file_data, this, data); 310 gcc_assert (DECL_INITIAL (decl) != error_mark_node); 311 lto_stats.num_function_bodies++; 312 lto_free_section_data (file_data, LTO_section_function_body, name, 313 data, len, decl_state->compressed); 314 lto_free_function_in_decl_state_for_node (this); 315 timevar_pop (TV_IPA_LTO_CTORS_IN); 316 return DECL_INITIAL (decl); 317} 318 319/* Return true if variable has constructor that can be used for folding. */ 320 321bool 322varpool_node::ctor_useable_for_folding_p (void) 323{ 324 varpool_node *real_node = this; 325 326 if (real_node->alias && real_node->definition) 327 real_node = ultimate_alias_target (); 328 329 if (TREE_CODE (decl) == CONST_DECL 330 || DECL_IN_CONSTANT_POOL (decl)) 331 return true; 332 if (TREE_THIS_VOLATILE (decl)) 333 return false; 334 335 /* Avoid attempts to load constructors that was not streamed. */ 336 if (in_lto_p && DECL_INITIAL (real_node->decl) == error_mark_node 337 && real_node->body_removed) 338 return false; 339 340 /* If we do not have a constructor, we can't use it. */ 341 if (DECL_INITIAL (real_node->decl) == error_mark_node 342 && !real_node->lto_file_data) 343 return false; 344 345 /* Vtables are defined by their types and must match no matter of interposition 346 rules. */ 347 if (DECL_VIRTUAL_P (decl)) 348 { 349 /* The C++ front end creates VAR_DECLs for vtables of typeinfo 350 classes not defined in the current TU so that it can refer 351 to them from typeinfo objects. Avoid returning NULL_TREE. */ 352 return DECL_INITIAL (real_node->decl) != NULL; 353 } 354 355 /* An alias of a read-only variable is also read-only, since the variable 356 is stored in read-only memory. We also accept read-only aliases of 357 non-read-only locations assuming that the user knows what he is asking 358 for. */ 359 if (!TREE_READONLY (decl) && !TREE_READONLY (real_node->decl)) 360 return false; 361 362 /* Variables declared 'const' without an initializer 363 have zero as the initializer if they may not be 364 overridden at link or run time. 365 366 It is actually requirement for C++ compiler to optimize const variables 367 consistently. As a GNU extension, do not enforce this rule for user defined 368 weak variables, so we support interposition on: 369 static const int dummy = 0; 370 extern const int foo __attribute__((__weak__, __alias__("dummy"))); 371 */ 372 if ((!DECL_INITIAL (real_node->decl) 373 || (DECL_WEAK (decl) && !DECL_COMDAT (decl))) 374 && (DECL_EXTERNAL (decl) || decl_replaceable_p (decl))) 375 return false; 376 377 /* Variables declared `const' with an initializer are considered 378 to not be overwritable with different initializer by default. 379 380 ??? Previously we behaved so for scalar variables but not for array 381 accesses. */ 382 return true; 383} 384 385/* If DECLARATION is constant variable and its initial value is known 386 (so we can do constant folding), return its constructor (DECL_INITIAL). 387 This may be an expression or NULL when DECL is initialized to 0. 388 Return ERROR_MARK_NODE otherwise. 389 390 In LTO this may actually trigger reading the constructor from disk. 391 For this reason varpool_ctor_useable_for_folding_p should be used when 392 the actual constructor value is not needed. */ 393 394tree 395ctor_for_folding (tree decl) 396{ 397 varpool_node *node, *real_node; 398 tree real_decl; 399 400 if (!VAR_P (decl) && TREE_CODE (decl) != CONST_DECL) 401 return error_mark_node; 402 403 if (TREE_CODE (decl) == CONST_DECL 404 || DECL_IN_CONSTANT_POOL (decl)) 405 return DECL_INITIAL (decl); 406 407 if (TREE_THIS_VOLATILE (decl)) 408 return error_mark_node; 409 410 /* Do not care about automatic variables. Those are never initialized 411 anyway, because gimplifier expands the code. */ 412 if (!TREE_STATIC (decl) && !DECL_EXTERNAL (decl)) 413 { 414 gcc_assert (!TREE_PUBLIC (decl)); 415 return error_mark_node; 416 } 417 418 gcc_assert (VAR_P (decl)); 419 420 real_node = node = varpool_node::get (decl); 421 if (node) 422 { 423 real_node = node->ultimate_alias_target (); 424 real_decl = real_node->decl; 425 } 426 else 427 real_decl = decl; 428 429 /* See if we are dealing with alias. 430 In most cases alias is just alternative symbol pointing to a given 431 constructor. This allows us to use interposition rules of DECL 432 constructor of REAL_NODE. However weakrefs are special by being just 433 alternative name of their target (if defined). */ 434 if (decl != real_decl) 435 { 436 gcc_assert (!DECL_INITIAL (decl) 437 || (node->alias && node->get_alias_target () == real_node) 438 || DECL_INITIAL (decl) == error_mark_node); 439 while (node->transparent_alias && node->analyzed) 440 { 441 node = node->get_alias_target (); 442 decl = node->decl; 443 } 444 } 445 446 if ((!DECL_VIRTUAL_P (real_decl) 447 || DECL_INITIAL (real_decl) == error_mark_node 448 || !DECL_INITIAL (real_decl)) 449 && (!node || !node->ctor_useable_for_folding_p ())) 450 return error_mark_node; 451 452 /* OK, we can return constructor. See if we need to fetch it from disk 453 in LTO mode. */ 454 if (DECL_INITIAL (real_decl) != error_mark_node 455 || !in_lto_p) 456 return DECL_INITIAL (real_decl); 457 return real_node->get_constructor (); 458} 459 460/* Add the variable DECL to the varpool. 461 Unlike finalize_decl function is intended to be used 462 by middle end and allows insertion of new variable at arbitrary point 463 of compilation. */ 464void 465varpool_node::add (tree decl) 466{ 467 varpool_node *node; 468 varpool_node::finalize_decl (decl); 469 node = varpool_node::get_create (decl); 470 symtab->call_varpool_insertion_hooks (node); 471 if (node->externally_visible_p ()) 472 node->externally_visible = true; 473 if (lookup_attribute ("no_reorder", DECL_ATTRIBUTES (decl))) 474 node->no_reorder = 1; 475} 476 477/* Return variable availability. See cgraph.h for description of individual 478 return values. */ 479enum availability 480varpool_node::get_availability (symtab_node *ref) 481{ 482 if (!definition) 483 return AVAIL_NOT_AVAILABLE; 484 if (!TREE_PUBLIC (decl)) 485 return AVAIL_AVAILABLE; 486 if (DECL_IN_CONSTANT_POOL (decl) 487 || DECL_VIRTUAL_P (decl)) 488 return AVAIL_AVAILABLE; 489 if (transparent_alias && definition) 490 { 491 enum availability avail; 492 493 ultimate_alias_target (&avail, ref); 494 return avail; 495 } 496 /* If this is a reference from symbol itself and there are no aliases, we 497 may be sure that the symbol was not interposed by something else because 498 the symbol itself would be unreachable otherwise. */ 499 if ((this == ref && !has_aliases_p ()) 500 || (ref && get_comdat_group () 501 && get_comdat_group () == ref->get_comdat_group ())) 502 return AVAIL_AVAILABLE; 503 /* If the variable can be overwritten, return OVERWRITABLE. Takes 504 care of at least one notable extension - the COMDAT variables 505 used to share template instantiations in C++. */ 506 if (decl_replaceable_p (decl) 507 || DECL_EXTERNAL (decl)) 508 return AVAIL_INTERPOSABLE; 509 return AVAIL_AVAILABLE; 510} 511 512void 513varpool_node::analyze (void) 514{ 515 /* When reading back varpool at LTO time, we re-construct the queue in order 516 to have "needed" list right by inserting all needed nodes into varpool. 517 We however don't want to re-analyze already analyzed nodes. */ 518 if (!analyzed) 519 { 520 gcc_assert (!in_lto_p || symtab->function_flags_ready); 521 /* Compute the alignment early so function body expanders are 522 already informed about increased alignment. */ 523 align_variable (decl, 0); 524 } 525 if (alias) 526 resolve_alias (varpool_node::get (alias_target)); 527 else if (DECL_INITIAL (decl)) 528 record_references_in_initializer (decl, analyzed); 529 analyzed = true; 530} 531 532/* Assemble thunks and aliases associated to varpool node. */ 533 534void 535varpool_node::assemble_aliases (void) 536{ 537 ipa_ref *ref; 538 539 FOR_EACH_ALIAS (this, ref) 540 { 541 varpool_node *alias = dyn_cast <varpool_node *> (ref->referring); 542 if (alias->symver) 543 do_assemble_symver (alias->decl, 544 DECL_ASSEMBLER_NAME (decl)); 545 else if (!alias->transparent_alias) 546 do_assemble_alias (alias->decl, 547 DECL_ASSEMBLER_NAME (decl)); 548 alias->assemble_aliases (); 549 } 550} 551 552/* Output one variable, if necessary. Return whether we output it. */ 553 554bool 555varpool_node::assemble_decl (void) 556{ 557 /* Aliases are output when their target is produced or by 558 output_weakrefs. */ 559 if (alias) 560 return false; 561 562 /* Constant pool is output from RTL land when the reference 563 survive till this level. */ 564 if (DECL_IN_CONSTANT_POOL (decl) && TREE_ASM_WRITTEN (decl)) 565 return false; 566 567 /* Decls with VALUE_EXPR should not be in the varpool at all. They 568 are not real variables, but just info for debugging and codegen. 569 Unfortunately at the moment emutls is not updating varpool correctly 570 after turning real vars into value_expr vars. */ 571 if (DECL_HAS_VALUE_EXPR_P (decl) 572 && !targetm.have_tls) 573 return false; 574 575 /* Hard register vars do not need to be output. */ 576 if (DECL_HARD_REGISTER (decl)) 577 return false; 578 579 gcc_checking_assert (!TREE_ASM_WRITTEN (decl) 580 && VAR_P (decl) 581 && !DECL_HAS_VALUE_EXPR_P (decl)); 582 583 if (!in_other_partition 584 && !DECL_EXTERNAL (decl)) 585 { 586 get_constructor (); 587 assemble_variable (decl, 0, 1, 0); 588 gcc_assert (TREE_ASM_WRITTEN (decl)); 589 gcc_assert (definition); 590 assemble_aliases (); 591 /* After the parser has generated debugging information, augment 592 this information with any new location/etc information that may 593 have become available after the compilation proper. */ 594 debug_hooks->late_global_decl (decl); 595 return true; 596 } 597 598 return false; 599} 600 601/* Add NODE to queue starting at FIRST. 602 The queue is linked via AUX pointers and terminated by pointer to 1. */ 603 604static void 605enqueue_node (varpool_node *node, varpool_node **first) 606{ 607 if (node->aux) 608 return; 609 gcc_checking_assert (*first); 610 node->aux = *first; 611 *first = node; 612} 613 614/* Optimization of function bodies might've rendered some variables as 615 unnecessary so we want to avoid these from being compiled. Re-do 616 reachability starting from variables that are either externally visible 617 or was referred from the asm output routines. */ 618 619void 620symbol_table::remove_unreferenced_decls (void) 621{ 622 varpool_node *next, *node; 623 varpool_node *first = (varpool_node *)(void *)1; 624 int i; 625 ipa_ref *ref = NULL; 626 hash_set<varpool_node *> referenced; 627 628 if (seen_error ()) 629 return; 630 631 if (dump_file) 632 fprintf (dump_file, "Trivially needed variables:"); 633 FOR_EACH_DEFINED_VARIABLE (node) 634 { 635 if (node->analyzed 636 && (!node->can_remove_if_no_refs_p () 637 /* We just expanded all function bodies. See if any of 638 them needed the variable. */ 639 || DECL_RTL_SET_P (node->decl))) 640 { 641 enqueue_node (node, &first); 642 if (dump_file) 643 fprintf (dump_file, " %s", node->dump_asm_name ()); 644 } 645 } 646 while (first != (varpool_node *)(void *)1) 647 { 648 node = first; 649 first = (varpool_node *)first->aux; 650 651 if (node->same_comdat_group) 652 { 653 symtab_node *next; 654 for (next = node->same_comdat_group; 655 next != node; 656 next = next->same_comdat_group) 657 { 658 varpool_node *vnext = dyn_cast <varpool_node *> (next); 659 if (vnext && vnext->analyzed && !next->comdat_local_p ()) 660 enqueue_node (vnext, &first); 661 } 662 } 663 for (i = 0; node->iterate_reference (i, ref); i++) 664 { 665 varpool_node *vnode = dyn_cast <varpool_node *> (ref->referred); 666 if (vnode 667 && !vnode->in_other_partition 668 && (!DECL_EXTERNAL (ref->referred->decl) 669 || vnode->alias) 670 && vnode->analyzed) 671 enqueue_node (vnode, &first); 672 else 673 { 674 referenced.add (vnode); 675 while (vnode && vnode->alias && vnode->definition) 676 { 677 vnode = vnode->get_alias_target (); 678 referenced.add (vnode); 679 } 680 } 681 } 682 } 683 if (dump_file) 684 fprintf (dump_file, "\nRemoving variables:"); 685 for (node = first_defined_variable (); node; node = next) 686 { 687 next = next_defined_variable (node); 688 if (!node->aux && !node->no_reorder) 689 { 690 if (dump_file) 691 fprintf (dump_file, " %s", node->dump_asm_name ()); 692 if (referenced.contains(node)) 693 node->remove_initializer (); 694 else 695 node->remove (); 696 } 697 } 698 699 if (dump_file) 700 fprintf (dump_file, "\n"); 701} 702 703/* For variables in named sections make sure get_variable_section 704 is called before we switch to those sections. Then section 705 conflicts between read-only and read-only requiring relocations 706 sections can be resolved. */ 707void 708varpool_node::finalize_named_section_flags (void) 709{ 710 if (!TREE_ASM_WRITTEN (decl) 711 && !alias 712 && !in_other_partition 713 && !DECL_EXTERNAL (decl) 714 && VAR_P (decl) 715 && !DECL_HAS_VALUE_EXPR_P (decl) 716 && get_section ()) 717 get_variable_section (decl, false); 718} 719 720/* Output all variables enqueued to be assembled. */ 721bool 722symbol_table::output_variables (void) 723{ 724 bool changed = false; 725 varpool_node *node; 726 727 if (seen_error ()) 728 return false; 729 730 remove_unreferenced_decls (); 731 732 timevar_push (TV_VAROUT); 733 734 FOR_EACH_DEFINED_VARIABLE (node) 735 { 736 /* Handled in output_in_order. */ 737 if (node->no_reorder) 738 continue; 739 740 node->finalize_named_section_flags (); 741 } 742 743 /* There is a similar loop in output_in_order. Please keep them in sync. */ 744 FOR_EACH_VARIABLE (node) 745 { 746 /* Handled in output_in_order. */ 747 if (node->no_reorder) 748 continue; 749 if (DECL_HARD_REGISTER (node->decl) 750 || DECL_HAS_VALUE_EXPR_P (node->decl)) 751 continue; 752 if (node->definition) 753 changed |= node->assemble_decl (); 754 else 755 assemble_undefined_decl (node->decl); 756 } 757 timevar_pop (TV_VAROUT); 758 return changed; 759} 760 761/* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful. 762 Extra name aliases are output whenever DECL is output. */ 763 764varpool_node * 765varpool_node::create_alias (tree alias, tree decl) 766{ 767 varpool_node *alias_node; 768 769 gcc_assert (VAR_P (decl)); 770 gcc_assert (VAR_P (alias)); 771 alias_node = varpool_node::get_create (alias); 772 alias_node->alias = true; 773 alias_node->definition = true; 774 alias_node->alias_target = decl; 775 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias)) != NULL) 776 alias_node->weakref = alias_node->transparent_alias = true; 777 return alias_node; 778} 779 780/* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful. 781 Extra name aliases are output whenever DECL is output. */ 782 783varpool_node * 784varpool_node::create_extra_name_alias (tree alias, tree decl) 785{ 786 varpool_node *alias_node; 787 788 /* If aliases aren't supported by the assembler, fail. */ 789 if (!TARGET_SUPPORTS_ALIASES) 790 return NULL; 791 792 alias_node = varpool_node::create_alias (alias, decl); 793 alias_node->cpp_implicit_alias = true; 794 795 /* Extra name alias mechanism creates aliases really late 796 via DECL_ASSEMBLER_NAME mechanism. 797 This is unfortunate because they are not going through the 798 standard channels. Ensure they get output. */ 799 if (symtab->cpp_implicit_aliases_done) 800 alias_node->resolve_alias (varpool_node::get_create (decl)); 801 return alias_node; 802} 803 804/* Worker for call_for_symbol_and_aliases. */ 805 806bool 807varpool_node::call_for_symbol_and_aliases_1 (bool (*callback) (varpool_node *, 808 void *), 809 void *data, 810 bool include_overwritable) 811{ 812 ipa_ref *ref; 813 814 FOR_EACH_ALIAS (this, ref) 815 { 816 varpool_node *alias = dyn_cast <varpool_node *> (ref->referring); 817 if (include_overwritable 818 || alias->get_availability () > AVAIL_INTERPOSABLE) 819 if (alias->call_for_symbol_and_aliases (callback, data, 820 include_overwritable)) 821 return true; 822 } 823 return false; 824} 825