1 /* Callgraph handling code. 2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011 3 Free Software Foundation, Inc. 4 Contributed by Jan Hubicka 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify it under 9 the terms of the GNU General Public License as published by the Free 10 Software Foundation; either version 3, or (at your option) any later 11 version. 12 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16 for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 21 22 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "tm.h" 26 #include "tree.h" 27 #include "cgraph.h" 28 #include "langhooks.h" 29 #include "diagnostic-core.h" 30 #include "hashtab.h" 31 #include "ggc.h" 32 #include "timevar.h" 33 #include "debug.h" 34 #include "target.h" 35 #include "output.h" 36 #include "gimple.h" 37 #include "tree-flow.h" 38 #include "flags.h" 39 40 /* This file contains basic routines manipulating variable pool. 41 42 Varpool acts as interface in between the front-end and middle-end 43 and drives the decision process on what variables and when are 44 going to be compiled. 45 46 The varpool nodes are allocated lazily for declarations 47 either by frontend or at callgraph construction time. 48 All variables supposed to be output into final file needs to be 49 explicitly marked by frontend via VARPOOL_FINALIZE_DECL function. */ 50 51 /* Hash table used to convert declarations into nodes. */ 52 static GTY((param_is (struct varpool_node))) htab_t varpool_hash; 53 54 /* The linked list of cgraph varpool nodes. 55 Linked via node->next pointer. */ 56 struct varpool_node *varpool_nodes; 57 58 /* Queue of cgraph nodes scheduled to be lowered and output. 59 The queue is maintained via mark_needed_node, linked via node->next_needed 60 pointer. 61 62 LAST_NEEDED_NODE points to the end of queue, so it can be 63 maintained in forward order. GTY is needed to make it friendly to 64 PCH. 65 66 During compilation we construct the queue of needed variables 67 twice: first time it is during cgraph construction, second time it is at the 68 end of compilation in VARPOOL_REMOVE_UNREFERENCED_DECLS so we can avoid 69 optimized out variables being output. 70 71 Each variable is thus first analyzed and then later possibly output. 72 FIRST_UNANALYZED_NODE points to first node in queue that was not analyzed 73 yet and is moved via VARPOOL_ANALYZE_PENDING_DECLS. */ 74 75 struct varpool_node *varpool_nodes_queue; 76 static GTY(()) struct varpool_node *varpool_last_needed_node; 77 static GTY(()) struct varpool_node *varpool_first_unanalyzed_node; 78 79 /* Lists all assembled variables to be sent to debugger output later on. */ 80 static GTY(()) struct varpool_node *varpool_assembled_nodes_queue; 81 82 /* Return name of the node used in debug output. */ 83 const char * 84 varpool_node_name (struct varpool_node *node) 85 { 86 return lang_hooks.decl_printable_name (node->decl, 2); 87 } 88 89 /* Returns a hash code for P. */ 90 static hashval_t 91 hash_varpool_node (const void *p) 92 { 93 const struct varpool_node *n = (const struct varpool_node *) p; 94 return (hashval_t) DECL_UID (n->decl); 95 } 96 97 /* Returns nonzero if P1 and P2 are equal. */ 98 static int 99 eq_varpool_node (const void *p1, const void *p2) 100 { 101 const struct varpool_node *n1 = 102 (const struct varpool_node *) p1; 103 const struct varpool_node *n2 = 104 (const struct varpool_node *) p2; 105 return DECL_UID (n1->decl) == DECL_UID (n2->decl); 106 } 107 108 /* Return varpool node assigned to DECL without creating new one. */ 109 struct varpool_node * 110 varpool_get_node (const_tree decl) 111 { 112 struct varpool_node key, **slot; 113 114 gcc_assert (TREE_CODE (decl) == VAR_DECL 115 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))); 116 117 if (!varpool_hash) 118 return NULL; 119 key.decl = CONST_CAST2 (tree, const_tree, decl); 120 slot = (struct varpool_node **) 121 htab_find_slot (varpool_hash, &key, NO_INSERT); 122 if (!slot) 123 return NULL; 124 return *slot; 125 } 126 127 /* Return varpool node assigned to DECL. Create new one when needed. */ 128 struct varpool_node * 129 varpool_node (tree decl) 130 { 131 struct varpool_node key, *node, **slot; 132 133 gcc_assert (TREE_CODE (decl) == VAR_DECL 134 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl) || in_lto_p)); 135 136 if (!varpool_hash) 137 varpool_hash = htab_create_ggc (10, hash_varpool_node, 138 eq_varpool_node, NULL); 139 key.decl = decl; 140 slot = (struct varpool_node **) 141 htab_find_slot (varpool_hash, &key, INSERT); 142 if (*slot) 143 return *slot; 144 node = ggc_alloc_cleared_varpool_node (); 145 node->decl = decl; 146 node->order = cgraph_order++; 147 node->next = varpool_nodes; 148 ipa_empty_ref_list (&node->ref_list); 149 if (varpool_nodes) 150 varpool_nodes->prev = node; 151 varpool_nodes = node; 152 *slot = node; 153 return node; 154 } 155 156 /* Remove node from the varpool. */ 157 void 158 varpool_remove_node (struct varpool_node *node) 159 { 160 void **slot; 161 slot = htab_find_slot (varpool_hash, node, NO_INSERT); 162 gcc_assert (*slot == node); 163 htab_clear_slot (varpool_hash, slot); 164 gcc_assert (!varpool_assembled_nodes_queue); 165 if (node->next) 166 node->next->prev = node->prev; 167 if (node->prev) 168 node->prev->next = node->next; 169 else 170 { 171 gcc_assert (varpool_nodes == node); 172 varpool_nodes = node->next; 173 } 174 if (varpool_first_unanalyzed_node == node) 175 varpool_first_unanalyzed_node = node->next_needed; 176 if (node->next_needed) 177 node->next_needed->prev_needed = node->prev_needed; 178 else if (node->prev_needed) 179 { 180 gcc_assert (varpool_last_needed_node); 181 varpool_last_needed_node = node->prev_needed; 182 } 183 if (node->prev_needed) 184 node->prev_needed->next_needed = node->next_needed; 185 else if (node->next_needed) 186 { 187 gcc_assert (varpool_nodes_queue == node); 188 varpool_nodes_queue = node->next_needed; 189 } 190 if (node->same_comdat_group) 191 { 192 struct varpool_node *prev; 193 for (prev = node->same_comdat_group; 194 prev->same_comdat_group != node; 195 prev = prev->same_comdat_group) 196 ; 197 if (node->same_comdat_group == prev) 198 prev->same_comdat_group = NULL; 199 else 200 prev->same_comdat_group = node->same_comdat_group; 201 node->same_comdat_group = NULL; 202 } 203 ipa_remove_all_references (&node->ref_list); 204 ipa_remove_all_refering (&node->ref_list); 205 ggc_free (node); 206 } 207 208 /* Dump given cgraph node. */ 209 void 210 dump_varpool_node (FILE *f, struct varpool_node *node) 211 { 212 fprintf (f, "%s:", varpool_node_name (node)); 213 fprintf (f, " availability:%s", 214 cgraph_function_flags_ready 215 ? cgraph_availability_names[cgraph_variable_initializer_availability (node)] 216 : "not-ready"); 217 if (DECL_ASSEMBLER_NAME_SET_P (node->decl)) 218 fprintf (f, " (asm: %s)", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node->decl))); 219 if (DECL_INITIAL (node->decl)) 220 fprintf (f, " initialized"); 221 if (TREE_ASM_WRITTEN (node->decl)) 222 fprintf (f, " (asm written)"); 223 if (node->needed) 224 fprintf (f, " needed"); 225 if (node->analyzed) 226 fprintf (f, " analyzed"); 227 if (node->finalized) 228 fprintf (f, " finalized"); 229 if (node->output) 230 fprintf (f, " output"); 231 if (node->externally_visible) 232 fprintf (f, " externally_visible"); 233 if (node->resolution != LDPR_UNKNOWN) 234 fprintf (f, " %s", 235 ld_plugin_symbol_resolution_names[(int)node->resolution]); 236 if (node->in_other_partition) 237 fprintf (f, " in_other_partition"); 238 else if (node->used_from_other_partition) 239 fprintf (f, " used_from_other_partition"); 240 fprintf (f, "\n"); 241 fprintf (f, " References: "); 242 ipa_dump_references (f, &node->ref_list); 243 fprintf (f, " Refering this var: "); 244 ipa_dump_refering (f, &node->ref_list); 245 } 246 247 /* Dump the variable pool. */ 248 void 249 dump_varpool (FILE *f) 250 { 251 struct varpool_node *node; 252 253 fprintf (f, "variable pool:\n\n"); 254 for (node = varpool_nodes; node; node = node->next) 255 dump_varpool_node (f, node); 256 } 257 258 /* Dump the variable pool to stderr. */ 259 260 DEBUG_FUNCTION void 261 debug_varpool (void) 262 { 263 dump_varpool (stderr); 264 } 265 266 /* Given an assembler name, lookup node. */ 267 struct varpool_node * 268 varpool_node_for_asm (tree asmname) 269 { 270 struct varpool_node *node; 271 272 for (node = varpool_nodes; node ; node = node->next) 273 if (decl_assembler_name_equal (node->decl, asmname)) 274 return node; 275 276 return NULL; 277 } 278 279 /* Helper function for finalization code - add node into lists so it will 280 be analyzed and compiled. */ 281 static void 282 varpool_enqueue_needed_node (struct varpool_node *node) 283 { 284 if (varpool_last_needed_node) 285 { 286 varpool_last_needed_node->next_needed = node; 287 node->prev_needed = varpool_last_needed_node; 288 } 289 varpool_last_needed_node = node; 290 node->next_needed = NULL; 291 if (!varpool_nodes_queue) 292 varpool_nodes_queue = node; 293 if (!varpool_first_unanalyzed_node) 294 varpool_first_unanalyzed_node = node; 295 notice_global_symbol (node->decl); 296 } 297 298 /* Notify finalize_compilation_unit that given node is reachable 299 or needed. */ 300 void 301 varpool_mark_needed_node (struct varpool_node *node) 302 { 303 if (!node->needed && node->finalized 304 && !TREE_ASM_WRITTEN (node->decl)) 305 varpool_enqueue_needed_node (node); 306 node->needed = 1; 307 } 308 309 /* Reset the queue of needed nodes. */ 310 void 311 varpool_reset_queue (void) 312 { 313 varpool_last_needed_node = NULL; 314 varpool_nodes_queue = NULL; 315 varpool_first_unanalyzed_node = NULL; 316 } 317 318 /* Determine if variable DECL is needed. That is, visible to something 319 either outside this translation unit, something magic in the system 320 configury */ 321 bool 322 decide_is_variable_needed (struct varpool_node *node, tree decl) 323 { 324 /* If the user told us it is used, then it must be so. */ 325 if (node->force_output) 326 return true; 327 328 gcc_assert (!DECL_EXTERNAL (decl)); 329 330 /* Externally visible variables must be output. The exception is 331 COMDAT variables that must be output only when they are needed. */ 332 if (TREE_PUBLIC (decl) 333 && !DECL_COMDAT (decl) 334 && !DECL_EXTERNAL (decl)) 335 return true; 336 337 /* When not reordering top level variables, we have to assume that 338 we are going to keep everything. */ 339 if (!flag_toplevel_reorder) 340 return true; 341 return false; 342 } 343 344 /* Return if DECL is constant and its initial value is known (so we can do 345 constant folding using DECL_INITIAL (decl)). */ 346 347 bool 348 const_value_known_p (tree decl) 349 { 350 if (TREE_CODE (decl) != VAR_DECL 351 &&TREE_CODE (decl) != CONST_DECL) 352 return false; 353 354 if (TREE_CODE (decl) == CONST_DECL 355 || DECL_IN_CONSTANT_POOL (decl)) 356 return true; 357 358 gcc_assert (TREE_CODE (decl) == VAR_DECL); 359 360 if (!TREE_READONLY (decl) || TREE_THIS_VOLATILE (decl)) 361 return false; 362 363 /* Gimplifier takes away constructors of local vars */ 364 if (!TREE_STATIC (decl) && !DECL_EXTERNAL (decl)) 365 return DECL_INITIAL (decl) != NULL; 366 367 gcc_assert (TREE_STATIC (decl) || DECL_EXTERNAL (decl)); 368 369 /* Variables declared 'const' without an initializer 370 have zero as the initializer if they may not be 371 overridden at link or run time. */ 372 if (!DECL_INITIAL (decl) 373 && (DECL_EXTERNAL (decl) 374 || 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 /* Mark DECL as finalized. By finalizing the declaration, frontend instruct the 386 middle end to output the variable to asm file, if needed or externally 387 visible. */ 388 void 389 varpool_finalize_decl (tree decl) 390 { 391 struct varpool_node *node = varpool_node (decl); 392 393 gcc_assert (TREE_STATIC (decl)); 394 395 /* The first declaration of a variable that comes through this function 396 decides whether it is global (in C, has external linkage) 397 or local (in C, has internal linkage). So do nothing more 398 if this function has already run. */ 399 if (node->finalized) 400 { 401 if (cgraph_global_info_ready) 402 varpool_assemble_pending_decls (); 403 return; 404 } 405 if (node->needed) 406 varpool_enqueue_needed_node (node); 407 node->finalized = true; 408 if (TREE_THIS_VOLATILE (decl) || DECL_PRESERVE_P (decl)) 409 node->force_output = true; 410 411 if (decide_is_variable_needed (node, decl)) 412 varpool_mark_needed_node (node); 413 if (cgraph_global_info_ready) 414 varpool_assemble_pending_decls (); 415 } 416 417 /* Add the variable DECL to the varpool. 418 Unlike varpool_finalize_decl function is intended to be used 419 by middle end and allows insertion of new variable at arbitrary point 420 of compilation. */ 421 void 422 varpool_add_new_variable (tree decl) 423 { 424 struct varpool_node *node; 425 varpool_finalize_decl (decl); 426 node = varpool_node (decl); 427 if (varpool_externally_visible_p (node, false)) 428 node->externally_visible = true; 429 } 430 431 /* Return variable availability. See cgraph.h for description of individual 432 return values. */ 433 enum availability 434 cgraph_variable_initializer_availability (struct varpool_node *node) 435 { 436 gcc_assert (cgraph_function_flags_ready); 437 if (!node->finalized) 438 return AVAIL_NOT_AVAILABLE; 439 if (!TREE_PUBLIC (node->decl)) 440 return AVAIL_AVAILABLE; 441 /* If the variable can be overwritten, return OVERWRITABLE. Takes 442 care of at least two notable extensions - the COMDAT variables 443 used to share template instantiations in C++. */ 444 if (!decl_replaceable_p (node->decl)) 445 return AVAIL_OVERWRITABLE; 446 return AVAIL_AVAILABLE; 447 } 448 449 /* Walk the decls we marked as necessary and see if they reference new 450 variables or functions and add them into the worklists. */ 451 bool 452 varpool_analyze_pending_decls (void) 453 { 454 bool changed = false; 455 456 timevar_push (TV_VARPOOL); 457 while (varpool_first_unanalyzed_node) 458 { 459 struct varpool_node *node = varpool_first_unanalyzed_node, *next; 460 tree decl = node->decl; 461 bool analyzed = node->analyzed; 462 463 varpool_first_unanalyzed_node->analyzed = true; 464 465 varpool_first_unanalyzed_node = varpool_first_unanalyzed_node->next_needed; 466 467 /* When reading back varpool at LTO time, we re-construct the queue in order 468 to have "needed" list right by inserting all needed nodes into varpool. 469 We however don't want to re-analyze already analyzed nodes. */ 470 if (!analyzed) 471 { 472 gcc_assert (!in_lto_p || cgraph_function_flags_ready); 473 /* Compute the alignment early so function body expanders are 474 already informed about increased alignment. */ 475 align_variable (decl, 0); 476 } 477 if (node->alias && node->alias_of) 478 { 479 struct varpool_node *tgt = varpool_node (node->alias_of); 480 struct varpool_node *n; 481 482 for (n = tgt; n && n->alias; 483 n = n->analyzed ? varpool_alias_aliased_node (n) : NULL) 484 if (n == node) 485 { 486 error ("variable %q+D part of alias cycle", node->decl); 487 node->alias = false; 488 continue; 489 } 490 if (!VEC_length (ipa_ref_t, node->ref_list.references)) 491 ipa_record_reference (NULL, node, NULL, tgt, IPA_REF_ALIAS, NULL); 492 /* C++ FE sometimes change linkage flags after producing same body aliases. */ 493 if (node->extra_name_alias) 494 { 495 DECL_WEAK (node->decl) = DECL_WEAK (node->alias_of); 496 TREE_PUBLIC (node->decl) = TREE_PUBLIC (node->alias_of); 497 DECL_EXTERNAL (node->decl) = DECL_EXTERNAL (node->alias_of); 498 DECL_VISIBILITY (node->decl) = DECL_VISIBILITY (node->alias_of); 499 if (TREE_PUBLIC (node->decl)) 500 { 501 DECL_COMDAT (node->decl) = DECL_COMDAT (node->alias_of); 502 DECL_COMDAT_GROUP (node->decl) = DECL_COMDAT_GROUP (node->alias_of); 503 if (DECL_ONE_ONLY (node->alias_of) && !node->same_comdat_group) 504 { 505 node->same_comdat_group = tgt; 506 if (!tgt->same_comdat_group) 507 tgt->same_comdat_group = node; 508 else 509 { 510 struct varpool_node *n; 511 for (n = tgt->same_comdat_group; 512 n->same_comdat_group != tgt; 513 n = n->same_comdat_group) 514 ; 515 n->same_comdat_group = node; 516 } 517 } 518 } 519 } 520 } 521 else if (DECL_INITIAL (decl)) 522 record_references_in_initializer (decl, analyzed); 523 if (node->same_comdat_group) 524 { 525 for (next = node->same_comdat_group; 526 next != node; 527 next = next->same_comdat_group) 528 varpool_mark_needed_node (next); 529 } 530 changed = true; 531 } 532 timevar_pop (TV_VARPOOL); 533 return changed; 534 } 535 536 /* Assemble thunks and aliases asociated to NODE. */ 537 538 static void 539 assemble_aliases (struct varpool_node *node) 540 { 541 int i; 542 struct ipa_ref *ref; 543 for (i = 0; ipa_ref_list_refering_iterate (&node->ref_list, i, ref); i++) 544 if (ref->use == IPA_REF_ALIAS) 545 { 546 struct varpool_node *alias = ipa_ref_refering_varpool_node (ref); 547 assemble_alias (alias->decl, 548 DECL_ASSEMBLER_NAME (alias->alias_of)); 549 assemble_aliases (alias); 550 } 551 } 552 553 /* Output one variable, if necessary. Return whether we output it. */ 554 bool 555 varpool_assemble_decl (struct varpool_node *node) 556 { 557 tree decl = node->decl; 558 559 if (!TREE_ASM_WRITTEN (decl) 560 && !node->alias 561 && !node->in_other_partition 562 && !DECL_EXTERNAL (decl) 563 && (TREE_CODE (decl) != VAR_DECL || !DECL_HAS_VALUE_EXPR_P (decl))) 564 { 565 assemble_variable (decl, 0, 1, 0); 566 if (TREE_ASM_WRITTEN (decl)) 567 { 568 node->next_needed = varpool_assembled_nodes_queue; 569 node->prev_needed = NULL; 570 if (varpool_assembled_nodes_queue) 571 varpool_assembled_nodes_queue->prev_needed = node; 572 varpool_assembled_nodes_queue = node; 573 node->finalized = 1; 574 assemble_aliases (node); 575 return true; 576 } 577 } 578 579 return false; 580 } 581 582 /* Optimization of function bodies might've rendered some variables as 583 unnecessary so we want to avoid these from being compiled. 584 585 This is done by pruning the queue and keeping only the variables that 586 really appear needed (ie they are either externally visible or referenced 587 by compiled function). Re-doing the reachability analysis on variables 588 brings back the remaining variables referenced by these. */ 589 void 590 varpool_remove_unreferenced_decls (void) 591 { 592 struct varpool_node *next, *node = varpool_nodes_queue; 593 594 varpool_reset_queue (); 595 596 if (seen_error ()) 597 return; 598 599 while (node) 600 { 601 next = node->next_needed; 602 node->needed = 0; 603 604 if (node->analyzed 605 && (!varpool_can_remove_if_no_refs (node) 606 /* We just expanded all function bodies. See if any of 607 them needed the variable. */ 608 || DECL_RTL_SET_P (node->decl))) 609 varpool_mark_needed_node (node); 610 611 node = next; 612 } 613 /* Make sure we mark alias targets as used targets. */ 614 finish_aliases_1 (); 615 varpool_analyze_pending_decls (); 616 } 617 618 /* For variables in named sections make sure get_variable_section 619 is called before we switch to those sections. Then section 620 conflicts between read-only and read-only requiring relocations 621 sections can be resolved. */ 622 void 623 varpool_finalize_named_section_flags (struct varpool_node *node) 624 { 625 if (!TREE_ASM_WRITTEN (node->decl) 626 && !node->alias 627 && !node->in_other_partition 628 && !DECL_EXTERNAL (node->decl) 629 && TREE_CODE (node->decl) == VAR_DECL 630 && !DECL_HAS_VALUE_EXPR_P (node->decl) 631 && DECL_SECTION_NAME (node->decl)) 632 get_variable_section (node->decl, false); 633 } 634 635 /* Output all variables enqueued to be assembled. */ 636 bool 637 varpool_assemble_pending_decls (void) 638 { 639 bool changed = false; 640 struct varpool_node *node; 641 642 if (seen_error ()) 643 return false; 644 645 timevar_push (TV_VAROUT); 646 /* EH might mark decls as needed during expansion. This should be safe since 647 we don't create references to new function, but it should not be used 648 elsewhere. */ 649 varpool_analyze_pending_decls (); 650 651 for (node = varpool_nodes_queue; node; node = node->next_needed) 652 varpool_finalize_named_section_flags (node); 653 654 while (varpool_nodes_queue) 655 { 656 struct varpool_node *node = varpool_nodes_queue; 657 658 varpool_nodes_queue = varpool_nodes_queue->next_needed; 659 if (varpool_assemble_decl (node)) 660 changed = true; 661 else 662 { 663 node->prev_needed = NULL; 664 node->next_needed = NULL; 665 } 666 } 667 /* varpool_nodes_queue is now empty, clear the pointer to the last element 668 in the queue. */ 669 varpool_last_needed_node = NULL; 670 timevar_pop (TV_VAROUT); 671 return changed; 672 } 673 674 /* Remove all elements from the queue so we can re-use it for debug output. */ 675 void 676 varpool_empty_needed_queue (void) 677 { 678 /* EH might mark decls as needed during expansion. This should be safe since 679 we don't create references to new function, but it should not be used 680 elsewhere. */ 681 varpool_analyze_pending_decls (); 682 683 while (varpool_nodes_queue) 684 { 685 struct varpool_node *node = varpool_nodes_queue; 686 varpool_nodes_queue = varpool_nodes_queue->next_needed; 687 node->next_needed = NULL; 688 node->prev_needed = NULL; 689 } 690 /* varpool_nodes_queue is now empty, clear the pointer to the last element 691 in the queue. */ 692 varpool_last_needed_node = NULL; 693 } 694 695 /* Create a new global variable of type TYPE. */ 696 tree 697 add_new_static_var (tree type) 698 { 699 tree new_decl; 700 struct varpool_node *new_node; 701 702 new_decl = create_tmp_var (type, NULL); 703 DECL_NAME (new_decl) = create_tmp_var_name (NULL); 704 TREE_READONLY (new_decl) = 0; 705 TREE_STATIC (new_decl) = 1; 706 TREE_USED (new_decl) = 1; 707 DECL_CONTEXT (new_decl) = NULL_TREE; 708 DECL_ABSTRACT (new_decl) = 0; 709 lang_hooks.dup_lang_specific_decl (new_decl); 710 create_var_ann (new_decl); 711 new_node = varpool_node (new_decl); 712 varpool_mark_needed_node (new_node); 713 add_referenced_var (new_decl); 714 varpool_finalize_decl (new_decl); 715 716 return new_node->decl; 717 } 718 719 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful. 720 Extra name aliases are output whenever DECL is output. */ 721 722 struct varpool_node * 723 varpool_create_variable_alias (tree alias, tree decl) 724 { 725 struct varpool_node *alias_node; 726 727 gcc_assert (TREE_CODE (decl) == VAR_DECL); 728 gcc_assert (TREE_CODE (alias) == VAR_DECL); 729 alias_node = varpool_node (alias); 730 alias_node->alias = 1; 731 if (!DECL_EXTERNAL (alias)) 732 alias_node->finalized = 1; 733 alias_node->alias_of = decl; 734 if ((!DECL_EXTERNAL (alias) 735 && decide_is_variable_needed (alias_node, alias)) 736 || alias_node->needed) 737 varpool_mark_needed_node (alias_node); 738 return alias_node; 739 } 740 741 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful. 742 Extra name aliases are output whenever DECL is output. */ 743 744 struct varpool_node * 745 varpool_extra_name_alias (tree alias, tree decl) 746 { 747 struct varpool_node *alias_node; 748 749 #ifndef ASM_OUTPUT_DEF 750 /* If aliases aren't supported by the assembler, fail. */ 751 return NULL; 752 #endif 753 alias_node = varpool_create_variable_alias (alias, decl); 754 alias_node->extra_name_alias = true; 755 return alias_node; 756 } 757 758 /* Return true when NODE is known to be used from other (non-LTO) object file. 759 Known only when doing LTO via linker plugin. */ 760 761 bool 762 varpool_used_from_object_file_p (struct varpool_node *node) 763 { 764 if (!TREE_PUBLIC (node->decl)) 765 return false; 766 if (resolution_used_from_other_file_p (node->resolution)) 767 return true; 768 return false; 769 } 770 771 /* Call calback on NODE and aliases asociated to NODE. 772 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are 773 skipped. */ 774 775 bool 776 varpool_for_node_and_aliases (struct varpool_node *node, 777 bool (*callback) (struct varpool_node *, void *), 778 void *data, 779 bool include_overwritable) 780 { 781 int i; 782 struct ipa_ref *ref; 783 784 if (callback (node, data)) 785 return true; 786 for (i = 0; ipa_ref_list_refering_iterate (&node->ref_list, i, ref); i++) 787 if (ref->use == IPA_REF_ALIAS) 788 { 789 struct varpool_node *alias = ipa_ref_refering_varpool_node (ref); 790 if (include_overwritable 791 || cgraph_variable_initializer_availability (alias) > AVAIL_OVERWRITABLE) 792 if (varpool_for_node_and_aliases (alias, callback, data, 793 include_overwritable)) 794 return true; 795 } 796 return false; 797 } 798 #include "gt-varpool.h" 799