1 /* Callgraph handling code.
2    Copyright (C) 2003-2018 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 *
add_varpool_removal_hook(varpool_node_hook hook,void * data)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
remove_varpool_removal_hook(varpool_node_hook_list * entry)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
call_varpool_removal_hooks(varpool_node * node)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 *
add_varpool_insertion_hook(varpool_node_hook hook,void * data)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
remove_varpool_insertion_hook(varpool_node_hook_list * entry)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
call_varpool_insertion_hooks(varpool_node * node)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 *
create_empty(void)135 varpool_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.  */
143 varpool_node *
get_create(tree decl)144 varpool_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 
172 void
remove(void)173 varpool_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.  */
196 void
remove_initializer(void)197 varpool_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.  */
214 void
dump(FILE * f)215 varpool_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.  */
debug(void)244 void varpool_node::debug (void)
245 {
246   varpool_node::dump (stderr);
247 }
248 
249 /* Dump the variable pool to F.  */
250 void
dump_varpool(FILE * f)251 varpool_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 
262 DEBUG_FUNCTION void
debug_varpool(void)263 varpool_node::debug_varpool (void)
264 {
265   dump_varpool (stderr);
266 }
267 
268 /* Given an assembler name, lookup node.  */
269 varpool_node *
get_for_asmname(tree asmname)270 varpool_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 
281 tree
get_constructor(void)282 varpool_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 
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   /* 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 
394 tree
ctor_for_folding(tree decl)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   /* 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.  */
470 void
add(tree decl)471 varpool_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.  */
485 enum availability
get_availability(symtab_node * ref)486 varpool_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 
518 void
analyze(void)519 varpool_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 
540 void
assemble_aliases(void)541 varpool_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 
557 bool
assemble_decl(void)558 varpool_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 
607 static void
enqueue_node(varpool_node * node,varpool_node ** first)608 enqueue_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 
622 void
remove_unreferenced_decls(void)623 symbol_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.  */
710 void
finalize_named_section_flags(void)711 varpool_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.  */
724 bool
output_variables(void)725 symbol_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 
767 varpool_node *
create_alias(tree alias,tree decl)768 varpool_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 
786 varpool_node *
create_extra_name_alias(tree alias,tree decl)787 varpool_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 
809 bool
call_for_symbol_and_aliases_1(bool (* callback)(varpool_node *,void *),void * data,bool include_overwritable)810 varpool_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