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