]> git.ipfire.org Git - thirdparty/gcc.git/blob - gcc/varpool.c
Update copyright years.
[thirdparty/gcc.git] / gcc / varpool.c
1 /* Callgraph handling code.
2 Copyright (C) 2003-2021 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
4
5 This file is part of GCC.
6
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.
11
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.
16
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/>. */
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
39 const 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. */
44 struct 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. */
51 varpool_node_hook_list *
52 symbol_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. */
68 void
69 symbol_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. */
80 void
81 symbol_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. */
92 varpool_node_hook_list *
93 symbol_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. */
109 void
110 symbol_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. */
121 void
122 symbol_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
134 varpool_node *
135 varpool_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. */
141 varpool_node *
142 varpool_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
170 void
171 varpool_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 (NULL);
190 ggc_free (this);
191 }
192
193 /* Remove node initializer when it is no longer needed. */
194 void
195 varpool_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. */
212 void
213 varpool_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. */
240 void varpool_node::debug (void)
241 {
242 varpool_node::dump (stderr);
243 }
244
245 /* Dump the variable pool to F. */
246 void
247 varpool_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
258 DEBUG_FUNCTION void
259 varpool_node::debug_varpool (void)
260 {
261 dump_varpool (stderr);
262 }
263
264 /* Given an assembler name, lookup node. */
265 varpool_node *
266 varpool_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
277 tree
278 varpool_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
321 bool
322 varpool_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
394 tree
395 ctor_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. */
464 void
465 varpool_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. */
479 enum availability
480 varpool_node::get_availability (symtab_node *ref)
481 {
482 if (!definition && !in_other_partition)
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
512 void
513 varpool_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
534 void
535 varpool_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
554 bool
555 varpool_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
604 static void
605 enqueue_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
619 void
620 symbol_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. */
707 void
708 varpool_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. */
721 bool
722 symbol_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
764 varpool_node *
765 varpool_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
783 varpool_node *
784 varpool_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
806 bool
807 varpool_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 }