[RS6000] PR79144, cmpstrnsi optimization breaks glibc
[official-gcc.git] / gcc / varpool.c
blobab59c80406ba7ff0b8d4af024c358f1de81b3991
1 /* Callgraph handling code.
2 Copyright (C) 2003-2017 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
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"
37 const char * const tls_model_names[]={"none", "emulated",
38 "global-dynamic", "local-dynamic",
39 "initial-exec", "local-exec"};
41 /* List of hooks triggered on varpool_node events. */
42 struct varpool_node_hook_list {
43 varpool_node_hook hook;
44 void *data;
45 struct varpool_node_hook_list *next;
48 /* Register HOOK to be called with DATA on each removed node. */
49 varpool_node_hook_list *
50 symbol_table::add_varpool_removal_hook (varpool_node_hook hook, void *data)
52 varpool_node_hook_list *entry;
53 varpool_node_hook_list **ptr = &m_first_varpool_removal_hook;
55 entry = (varpool_node_hook_list *) xmalloc (sizeof (*entry));
56 entry->hook = hook;
57 entry->data = data;
58 entry->next = NULL;
59 while (*ptr)
60 ptr = &(*ptr)->next;
61 *ptr = entry;
62 return entry;
65 /* Remove ENTRY from the list of hooks called on removing nodes. */
66 void
67 symbol_table::remove_varpool_removal_hook (varpool_node_hook_list *entry)
69 varpool_node_hook_list **ptr = &m_first_varpool_removal_hook;
71 while (*ptr != entry)
72 ptr = &(*ptr)->next;
73 *ptr = entry->next;
74 free (entry);
77 /* Call all node removal hooks. */
78 void
79 symbol_table::call_varpool_removal_hooks (varpool_node *node)
81 varpool_node_hook_list *entry = m_first_varpool_removal_hook;
82 while (entry)
84 entry->hook (node, entry->data);
85 entry = entry->next;
89 /* Register HOOK to be called with DATA on each inserted node. */
90 varpool_node_hook_list *
91 symbol_table::add_varpool_insertion_hook (varpool_node_hook hook, void *data)
93 varpool_node_hook_list *entry;
94 varpool_node_hook_list **ptr = &m_first_varpool_insertion_hook;
96 entry = (varpool_node_hook_list *) xmalloc (sizeof (*entry));
97 entry->hook = hook;
98 entry->data = data;
99 entry->next = NULL;
100 while (*ptr)
101 ptr = &(*ptr)->next;
102 *ptr = entry;
103 return entry;
106 /* Remove ENTRY from the list of hooks called on inserted nodes. */
107 void
108 symbol_table::remove_varpool_insertion_hook (varpool_node_hook_list *entry)
110 varpool_node_hook_list **ptr = &m_first_varpool_insertion_hook;
112 while (*ptr != entry)
113 ptr = &(*ptr)->next;
114 *ptr = entry->next;
115 free (entry);
118 /* Call all node insertion hooks. */
119 void
120 symbol_table::call_varpool_insertion_hooks (varpool_node *node)
122 varpool_node_hook_list *entry = m_first_varpool_insertion_hook;
123 while (entry)
125 entry->hook (node, entry->data);
126 entry = entry->next;
130 /* Allocate new callgraph node and insert it into basic data structures. */
132 varpool_node *
133 varpool_node::create_empty (void)
135 varpool_node *node = ggc_cleared_alloc<varpool_node> ();
136 node->type = SYMTAB_VARIABLE;
137 return node;
140 /* Return varpool node assigned to DECL. Create new one when needed. */
141 varpool_node *
142 varpool_node::get_create (tree decl)
144 varpool_node *node = varpool_node::get (decl);
145 gcc_checking_assert (VAR_P (decl));
146 if (node)
147 return node;
149 node = varpool_node::create_empty ();
150 node->decl = decl;
152 if ((flag_openacc || flag_openmp)
153 && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl)))
155 node->offloadable = 1;
156 if (ENABLE_OFFLOADING && !DECL_EXTERNAL (decl))
158 g->have_offload = true;
159 if (!in_lto_p)
160 vec_safe_push (offload_vars, decl);
164 node->register_symbol ();
165 return node;
168 /* Remove variable from symbol table. */
170 void
171 varpool_node::remove (void)
173 symtab->call_varpool_removal_hooks (this);
174 if (lto_file_data)
176 lto_free_function_in_decl_state_for_node (this);
177 lto_file_data = NULL;
180 /* When streaming we can have multiple nodes associated with decl. */
181 if (symtab->state == LTO_STREAMING)
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 ();
189 unregister ();
190 ggc_free (this);
193 /* Remove node initializer when it is no longer needed. */
194 void
195 varpool_node::remove_initializer (void)
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 boides, or we will end up remiving
206 wrong one. */
207 && symtab->state != LTO_STREAMING)
208 DECL_INITIAL (decl) = error_mark_node;
211 /* Dump given varpool node to F. */
212 void
213 varpool_node::dump (FILE *f)
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 (need_bounds_init)
228 fprintf (f, " need-bounds-init");
229 if (TREE_READONLY (decl))
230 fprintf (f, " read-only");
231 if (ctor_useable_for_folding_p ())
232 fprintf (f, " const-value-known");
233 if (writeonly)
234 fprintf (f, " write-only");
235 if (tls_model)
236 fprintf (f, " tls-%s", tls_model_names [tls_model]);
237 fprintf (f, "\n");
241 /* Dump given varpool node to stderr. */
242 void varpool_node::debug (void)
244 varpool_node::dump (stderr);
247 /* Dump the variable pool to F. */
248 void
249 varpool_node::dump_varpool (FILE *f)
251 varpool_node *node;
253 fprintf (f, "variable pool:\n\n");
254 FOR_EACH_VARIABLE (node)
255 node->dump (f);
258 /* Dump the variable pool to stderr. */
260 DEBUG_FUNCTION void
261 varpool_node::debug_varpool (void)
263 dump_varpool (stderr);
266 /* Given an assembler name, lookup node. */
267 varpool_node *
268 varpool_node::get_for_asmname (tree asmname)
270 if (symtab_node *node = symtab_node::get_for_asmname (asmname))
271 return dyn_cast <varpool_node *> (node);
272 else
273 return NULL;
276 /* When doing LTO, read variable's constructor from disk if
277 it is not already present. */
279 tree
280 varpool_node::get_constructor (void)
282 lto_file_decl_data *file_data;
283 const char *data, *name;
284 size_t len;
286 if (DECL_INITIAL (decl) != error_mark_node
287 || !in_lto_p
288 || !lto_file_data)
289 return DECL_INITIAL (decl);
291 timevar_push (TV_IPA_LTO_CTORS_IN);
293 file_data = lto_file_data;
294 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
296 /* We may have renamed the declaration, e.g., a static function. */
297 name = lto_get_decl_name_mapping (file_data, name);
298 struct lto_in_decl_state *decl_state
299 = lto_get_function_in_decl_state (file_data, decl);
301 data = lto_get_section_data (file_data, LTO_section_function_body,
302 name, &len, decl_state->compressed);
303 if (!data)
304 fatal_error (input_location, "%s: section %s is missing",
305 file_data->file_name,
306 name);
308 lto_input_variable_constructor (file_data, this, data);
309 gcc_assert (DECL_INITIAL (decl) != error_mark_node);
310 lto_stats.num_function_bodies++;
311 lto_free_section_data (file_data, LTO_section_function_body, name,
312 data, len, decl_state->compressed);
313 lto_free_function_in_decl_state_for_node (this);
314 timevar_pop (TV_IPA_LTO_CTORS_IN);
315 return DECL_INITIAL (decl);
318 /* Return true if variable has constructor that can be used for folding. */
320 bool
321 varpool_node::ctor_useable_for_folding_p (void)
323 varpool_node *real_node = this;
325 if (real_node->alias && real_node->definition)
326 real_node = ultimate_alias_target ();
328 if (TREE_CODE (decl) == CONST_DECL
329 || DECL_IN_CONSTANT_POOL (decl))
330 return true;
331 if (TREE_THIS_VOLATILE (decl))
332 return false;
334 /* If we do not have a constructor, we can't use it. */
335 if (DECL_INITIAL (real_node->decl) == error_mark_node
336 && !real_node->lto_file_data)
337 return false;
339 /* Avoid attempts to load constructors that was not streamed. */
340 if (flag_ltrans && DECL_INITIAL (real_node->decl) == error_mark_node
341 && real_node->body_removed)
342 return false;
344 /* Vtables are defined by their types and must match no matter of interposition
345 rules. */
346 if (DECL_VIRTUAL_P (decl))
348 /* The C++ front end creates VAR_DECLs for vtables of typeinfo
349 classes not defined in the current TU so that it can refer
350 to them from typeinfo objects. Avoid returning NULL_TREE. */
351 return DECL_INITIAL (real_node->decl) != NULL;
354 /* Alias of readonly variable is also readonly, since the variable is stored
355 in readonly memory. We also accept readonly aliases of non-readonly
356 locations assuming that user knows what he is asking for. */
357 if (!TREE_READONLY (decl) && !TREE_READONLY (real_node->decl))
358 return false;
360 /* Variables declared 'const' without an initializer
361 have zero as the initializer if they may not be
362 overridden at link or run time.
364 It is actually requirement for C++ compiler to optimize const variables
365 consistently. As a GNU extension, do not enfore this rule for user defined
366 weak variables, so we support interposition on:
367 static const int dummy = 0;
368 extern const int foo __attribute__((__weak__, __alias__("dummy")));
370 if ((!DECL_INITIAL (real_node->decl)
371 || (DECL_WEAK (decl) && !DECL_COMDAT (decl)))
372 && (DECL_EXTERNAL (decl) || decl_replaceable_p (decl)))
373 return false;
375 /* Variables declared `const' with an initializer are considered
376 to not be overwritable with different initializer by default.
378 ??? Previously we behaved so for scalar variables but not for array
379 accesses. */
380 return true;
383 /* If DECLARATION is constant variable and its initial value is known
384 (so we can do constant folding), return its constructor (DECL_INITIAL).
385 This may be an expression or NULL when DECL is initialized to 0.
386 Return ERROR_MARK_NODE otherwise.
388 In LTO this may actually trigger reading the constructor from disk.
389 For this reason varpool_ctor_useable_for_folding_p should be used when
390 the actual constructor value is not needed. */
392 tree
393 ctor_for_folding (tree decl)
395 varpool_node *node, *real_node;
396 tree real_decl;
398 if (!VAR_P (decl) && TREE_CODE (decl) != CONST_DECL)
399 return error_mark_node;
401 /* Static constant bounds are created to be
402 used instead of constants and therefore
403 do not let folding it. */
404 if (POINTER_BOUNDS_P (decl))
405 return error_mark_node;
407 if (TREE_CODE (decl) == CONST_DECL
408 || DECL_IN_CONSTANT_POOL (decl))
409 return DECL_INITIAL (decl);
411 if (TREE_THIS_VOLATILE (decl))
412 return error_mark_node;
414 /* Do not care about automatic variables. Those are never initialized
415 anyway, because gimplifier exapnds the code. */
416 if (!TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
418 gcc_assert (!TREE_PUBLIC (decl));
419 return error_mark_node;
422 gcc_assert (VAR_P (decl));
424 real_node = node = varpool_node::get (decl);
425 if (node)
427 real_node = node->ultimate_alias_target ();
428 real_decl = real_node->decl;
430 else
431 real_decl = decl;
433 /* See if we are dealing with alias.
434 In most cases alias is just alternative symbol pointing to a given
435 constructor. This allows us to use interposition rules of DECL
436 constructor of REAL_NODE. However weakrefs are special by being just
437 alternative name of their target (if defined). */
438 if (decl != real_decl)
440 gcc_assert (!DECL_INITIAL (decl)
441 || (node->alias && node->get_alias_target () == real_node)
442 || DECL_INITIAL (decl) == error_mark_node);
443 while (node->transparent_alias && node->analyzed)
445 node = node->get_alias_target ();
446 decl = node->decl;
450 if ((!DECL_VIRTUAL_P (real_decl)
451 || DECL_INITIAL (real_decl) == error_mark_node
452 || !DECL_INITIAL (real_decl))
453 && (!node || !node->ctor_useable_for_folding_p ()))
454 return error_mark_node;
456 /* OK, we can return constructor. See if we need to fetch it from disk
457 in LTO mode. */
458 if (DECL_INITIAL (real_decl) != error_mark_node
459 || !in_lto_p)
460 return DECL_INITIAL (real_decl);
461 return real_node->get_constructor ();
464 /* Add the variable DECL to the varpool.
465 Unlike finalize_decl function is intended to be used
466 by middle end and allows insertion of new variable at arbitrary point
467 of compilation. */
468 void
469 varpool_node::add (tree decl)
471 varpool_node *node;
472 varpool_node::finalize_decl (decl);
473 node = varpool_node::get_create (decl);
474 symtab->call_varpool_insertion_hooks (node);
475 if (node->externally_visible_p ())
476 node->externally_visible = true;
477 if (lookup_attribute ("no_reorder", DECL_ATTRIBUTES (decl)))
478 node->no_reorder = 1;
481 /* Return variable availability. See cgraph.h for description of individual
482 return values. */
483 enum availability
484 varpool_node::get_availability (symtab_node *ref)
486 if (!definition)
487 return AVAIL_NOT_AVAILABLE;
488 if (!TREE_PUBLIC (decl))
489 return AVAIL_AVAILABLE;
490 if (DECL_IN_CONSTANT_POOL (decl)
491 || DECL_VIRTUAL_P (decl))
492 return AVAIL_AVAILABLE;
493 if (transparent_alias && definition)
495 enum availability avail;
497 ultimate_alias_target (&avail, ref);
498 return avail;
500 /* If this is a reference from symbol itself and there are no aliases, we
501 may be sure that the symbol was not interposed by something else because
502 the symbol itself would be unreachable otherwise. */
503 if ((this == ref && !has_aliases_p ())
504 || (ref && get_comdat_group ()
505 && get_comdat_group () == ref->get_comdat_group ()))
506 return AVAIL_AVAILABLE;
507 /* If the variable can be overwritten, return OVERWRITABLE. Takes
508 care of at least one notable extension - the COMDAT variables
509 used to share template instantiations in C++. */
510 if (decl_replaceable_p (decl)
511 || DECL_EXTERNAL (decl))
512 return AVAIL_INTERPOSABLE;
513 return AVAIL_AVAILABLE;
516 void
517 varpool_node::analyze (void)
519 /* When reading back varpool at LTO time, we re-construct the queue in order
520 to have "needed" list right by inserting all needed nodes into varpool.
521 We however don't want to re-analyze already analyzed nodes. */
522 if (!analyzed)
524 gcc_assert (!in_lto_p || symtab->function_flags_ready);
525 /* Compute the alignment early so function body expanders are
526 already informed about increased alignment. */
527 align_variable (decl, 0);
529 if (alias)
530 resolve_alias (varpool_node::get (alias_target));
531 else if (DECL_INITIAL (decl))
532 record_references_in_initializer (decl, analyzed);
533 analyzed = true;
536 /* Assemble thunks and aliases associated to varpool node. */
538 void
539 varpool_node::assemble_aliases (void)
541 ipa_ref *ref;
543 FOR_EACH_ALIAS (this, ref)
545 varpool_node *alias = dyn_cast <varpool_node *> (ref->referring);
546 if (!alias->transparent_alias)
547 do_assemble_alias (alias->decl,
548 DECL_ASSEMBLER_NAME (decl));
549 alias->assemble_aliases ();
553 /* Output one variable, if necessary. Return whether we output it. */
555 bool
556 varpool_node::assemble_decl (void)
558 /* Aliases are outout when their target is produced or by
559 output_weakrefs. */
560 if (alias)
561 return false;
563 /* Constant pool is output from RTL land when the reference
564 survive till this level. */
565 if (DECL_IN_CONSTANT_POOL (decl) && TREE_ASM_WRITTEN (decl))
566 return false;
568 /* Decls with VALUE_EXPR should not be in the varpool at all. They
569 are not real variables, but just info for debugging and codegen.
570 Unfortunately at the moment emutls is not updating varpool correctly
571 after turning real vars into value_expr vars. */
572 if (DECL_HAS_VALUE_EXPR_P (decl)
573 && !targetm.have_tls)
574 return false;
576 /* Hard register vars do not need to be output. */
577 if (DECL_HARD_REGISTER (decl))
578 return false;
580 gcc_checking_assert (!TREE_ASM_WRITTEN (decl)
581 && VAR_P (decl)
582 && !DECL_HAS_VALUE_EXPR_P (decl));
584 if (!in_other_partition
585 && !DECL_EXTERNAL (decl))
587 get_constructor ();
588 assemble_variable (decl, 0, 1, 0);
589 gcc_assert (TREE_ASM_WRITTEN (decl));
590 gcc_assert (definition);
591 assemble_aliases ();
592 /* After the parser has generated debugging information, augment
593 this information with any new location/etc information that may
594 have become available after the compilation proper. */
595 debug_hooks->late_global_decl (decl);
596 return true;
599 return false;
602 /* Add NODE to queue starting at FIRST.
603 The queue is linked via AUX pointers and terminated by pointer to 1. */
605 static void
606 enqueue_node (varpool_node *node, varpool_node **first)
608 if (node->aux)
609 return;
610 gcc_checking_assert (*first);
611 node->aux = *first;
612 *first = node;
615 /* Optimization of function bodies might've rendered some variables as
616 unnecessary so we want to avoid these from being compiled. Re-do
617 reachability starting from variables that are either externally visible
618 or was referred from the asm output routines. */
620 void
621 symbol_table::remove_unreferenced_decls (void)
623 varpool_node *next, *node;
624 varpool_node *first = (varpool_node *)(void *)1;
625 int i;
626 ipa_ref *ref = NULL;
627 hash_set<varpool_node *> referenced;
629 if (seen_error ())
630 return;
632 if (dump_file)
633 fprintf (dump_file, "Trivially needed variables:");
634 FOR_EACH_DEFINED_VARIABLE (node)
636 if (node->analyzed
637 && (!node->can_remove_if_no_refs_p ()
638 /* We just expanded all function bodies. See if any of
639 them needed the variable. */
640 || DECL_RTL_SET_P (node->decl)))
642 enqueue_node (node, &first);
643 if (dump_file)
644 fprintf (dump_file, " %s", node->asm_name ());
647 while (first != (varpool_node *)(void *)1)
649 node = first;
650 first = (varpool_node *)first->aux;
652 if (node->same_comdat_group)
654 symtab_node *next;
655 for (next = node->same_comdat_group;
656 next != node;
657 next = next->same_comdat_group)
659 varpool_node *vnext = dyn_cast <varpool_node *> (next);
660 if (vnext && vnext->analyzed && !next->comdat_local_p ())
661 enqueue_node (vnext, &first);
664 for (i = 0; node->iterate_reference (i, ref); i++)
666 varpool_node *vnode = dyn_cast <varpool_node *> (ref->referred);
667 if (vnode
668 && !vnode->in_other_partition
669 && (!DECL_EXTERNAL (ref->referred->decl)
670 || vnode->alias)
671 && vnode->analyzed)
672 enqueue_node (vnode, &first);
673 else
675 referenced.add (vnode);
676 while (vnode && vnode->alias && vnode->definition)
678 vnode = vnode->get_alias_target ();
679 referenced.add (vnode);
684 if (dump_file)
685 fprintf (dump_file, "\nRemoving variables:");
686 for (node = first_defined_variable (); node; node = next)
688 next = next_defined_variable (node);
689 if (!node->aux && !node->no_reorder)
691 if (dump_file)
692 fprintf (dump_file, " %s", node->asm_name ());
693 if (referenced.contains(node))
694 node->remove_initializer ();
695 else
696 node->remove ();
700 if (dump_file)
701 fprintf (dump_file, "\n");
704 /* For variables in named sections make sure get_variable_section
705 is called before we switch to those sections. Then section
706 conflicts between read-only and read-only requiring relocations
707 sections can be resolved. */
708 void
709 varpool_node::finalize_named_section_flags (void)
711 if (!TREE_ASM_WRITTEN (decl)
712 && !alias
713 && !in_other_partition
714 && !DECL_EXTERNAL (decl)
715 && VAR_P (decl)
716 && !DECL_HAS_VALUE_EXPR_P (decl)
717 && get_section ())
718 get_variable_section (decl, false);
721 /* Output all variables enqueued to be assembled. */
722 bool
723 symbol_table::output_variables (void)
725 bool changed = false;
726 varpool_node *node;
728 if (seen_error ())
729 return false;
731 remove_unreferenced_decls ();
733 timevar_push (TV_VAROUT);
735 FOR_EACH_DEFINED_VARIABLE (node)
737 /* Handled in output_in_order. */
738 if (node->no_reorder)
739 continue;
741 node->finalize_named_section_flags ();
744 /* There is a similar loop in output_in_order. Please keep them in sync. */
745 FOR_EACH_VARIABLE (node)
747 /* Handled in output_in_order. */
748 if (node->no_reorder)
749 continue;
750 if (DECL_HARD_REGISTER (node->decl)
751 || DECL_HAS_VALUE_EXPR_P (node->decl))
752 continue;
753 if (node->definition)
754 changed |= node->assemble_decl ();
755 else
756 assemble_undefined_decl (node->decl);
758 timevar_pop (TV_VAROUT);
759 return changed;
762 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
763 Extra name aliases are output whenever DECL is output. */
765 varpool_node *
766 varpool_node::create_alias (tree alias, tree decl)
768 varpool_node *alias_node;
770 gcc_assert (VAR_P (decl));
771 gcc_assert (VAR_P (alias));
772 alias_node = varpool_node::get_create (alias);
773 alias_node->alias = true;
774 alias_node->definition = true;
775 alias_node->alias_target = decl;
776 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias)) != NULL)
777 alias_node->weakref = alias_node->transparent_alias = true;
778 return alias_node;
781 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
782 Extra name aliases are output whenever DECL is output. */
784 varpool_node *
785 varpool_node::create_extra_name_alias (tree alias, tree decl)
787 varpool_node *alias_node;
789 #ifndef ASM_OUTPUT_DEF
790 /* If aliases aren't supported by the assembler, fail. */
791 return NULL;
792 #endif
793 alias_node = varpool_node::create_alias (alias, decl);
794 alias_node->cpp_implicit_alias = true;
796 /* Extra name alias mechanizm creates aliases really late
797 via DECL_ASSEMBLER_NAME mechanizm.
798 This is unfortunate because they are not going through the
799 standard channels. Ensure they get output. */
800 if (symtab->cpp_implicit_aliases_done)
801 alias_node->resolve_alias (varpool_node::get_create (decl));
802 return alias_node;
805 /* Worker for call_for_symbol_and_aliases. */
807 bool
808 varpool_node::call_for_symbol_and_aliases_1 (bool (*callback) (varpool_node *,
809 void *),
810 void *data,
811 bool include_overwritable)
813 ipa_ref *ref;
815 FOR_EACH_ALIAS (this, ref)
817 varpool_node *alias = dyn_cast <varpool_node *> (ref->referring);
818 if (include_overwritable
819 || alias->get_availability () > AVAIL_INTERPOSABLE)
820 if (alias->call_for_symbol_and_aliases (callback, data,
821 include_overwritable))
822 return true;
824 return false;