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