1 /* Callgraph handling code.
2 Copyright (C) 2003-2014 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
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
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/>. */
23 #include "coretypes.h"
28 #include "langhooks.h"
29 #include "diagnostic-core.h"
35 #include "gimple-expr.h"
37 #include "tree-ssa-alias.h"
39 #include "lto-streamer.h"
42 const char * const tls_model_names
[]={"none", "tls-emulated", "tls-real",
43 "tls-global-dynamic", "tls-local-dynamic",
44 "tls-initial-exec", "tls-local-exec"};
46 /* List of hooks triggered on varpool_node events. */
47 struct varpool_node_hook_list
{
48 varpool_node_hook hook
;
50 struct varpool_node_hook_list
*next
;
53 /* Register HOOK to be called with DATA on each removed node. */
54 varpool_node_hook_list
*
55 symbol_table::add_varpool_removal_hook (varpool_node_hook hook
, void *data
)
57 varpool_node_hook_list
*entry
;
58 varpool_node_hook_list
**ptr
= &m_first_varpool_removal_hook
;
60 entry
= (varpool_node_hook_list
*) xmalloc (sizeof (*entry
));
70 /* Remove ENTRY from the list of hooks called on removing nodes. */
72 symbol_table::remove_varpool_removal_hook (varpool_node_hook_list
*entry
)
74 varpool_node_hook_list
**ptr
= &m_first_varpool_removal_hook
;
82 /* Call all node removal hooks. */
84 symbol_table::call_varpool_removal_hooks (varpool_node
*node
)
86 varpool_node_hook_list
*entry
= m_first_varpool_removal_hook
;
89 entry
->hook (node
, entry
->data
);
94 /* Register HOOK to be called with DATA on each inserted node. */
95 varpool_node_hook_list
*
96 symbol_table::add_varpool_insertion_hook (varpool_node_hook hook
, void *data
)
98 varpool_node_hook_list
*entry
;
99 varpool_node_hook_list
**ptr
= &m_first_varpool_insertion_hook
;
101 entry
= (varpool_node_hook_list
*) xmalloc (sizeof (*entry
));
111 /* Remove ENTRY from the list of hooks called on inserted nodes. */
113 symbol_table::remove_varpool_insertion_hook (varpool_node_hook_list
*entry
)
115 varpool_node_hook_list
**ptr
= &m_first_varpool_insertion_hook
;
117 while (*ptr
!= entry
)
123 /* Call all node insertion hooks. */
125 symbol_table::call_varpool_insertion_hooks (varpool_node
*node
)
127 varpool_node_hook_list
*entry
= m_first_varpool_insertion_hook
;
130 entry
->hook (node
, entry
->data
);
135 /* Allocate new callgraph node and insert it into basic data structures. */
138 varpool_node::create_empty (void)
140 varpool_node
*node
= ggc_cleared_alloc
<varpool_node
> ();
141 node
->type
= SYMTAB_VARIABLE
;
145 /* Return varpool node assigned to DECL. Create new one when needed. */
147 varpool_node::get_create (tree decl
)
149 varpool_node
*node
= varpool_node::get (decl
);
150 gcc_checking_assert (TREE_CODE (decl
) == VAR_DECL
);
154 node
= varpool_node::create_empty ();
156 node
->register_symbol ();
160 /* Remove variable from symbol table. */
163 varpool_node::remove (void)
165 symtab
->call_varpool_removal_hooks (this);
168 /* When streaming we can have multiple nodes associated with decl. */
169 if (symtab
->state
== LTO_STREAMING
)
171 /* Keep constructor when it may be used for folding. We remove
172 references to external variables before final compilation. */
173 else if (DECL_INITIAL (decl
) && DECL_INITIAL (decl
) != error_mark_node
174 && !ctor_useable_for_folding_p ())
175 remove_initializer ();
179 /* Remove node initializer when it is no longer needed. */
181 varpool_node::remove_initializer (void)
183 if (DECL_INITIAL (decl
)
184 && !DECL_IN_CONSTANT_POOL (decl
)
185 /* Keep vtables for BINFO folding. */
186 && !DECL_VIRTUAL_P (decl
)
187 /* FIXME: http://gcc.gnu.org/PR55395 */
188 && debug_info_level
== DINFO_LEVEL_NONE
189 /* When doing declaration merging we have duplicate
190 entries for given decl. Do not attempt to remove
191 the boides, or we will end up remiving
193 && symtab
->state
!= LTO_STREAMING
)
194 DECL_INITIAL (decl
) = error_mark_node
;
197 /* Dump given varpool node to F. */
199 varpool_node::dump (FILE *f
)
202 fprintf (f
, " Availability: %s\n",
203 symtab
->function_flags_ready
204 ? cgraph_availability_names
[get_availability ()]
206 fprintf (f
, " Varpool flags:");
207 if (DECL_INITIAL (decl
))
208 fprintf (f
, " initialized");
210 fprintf (f
, " output");
211 if (used_by_single_function
)
212 fprintf (f
, " used-by-single-function");
213 if (TREE_READONLY (decl
))
214 fprintf (f
, " read-only");
215 if (ctor_useable_for_folding_p ())
216 fprintf (f
, " const-value-known");
218 fprintf (f
, " write-only");
220 fprintf (f
, " %s", tls_model_names
[tls_model
]);
225 /* Dump given varpool node to stderr. */
226 void varpool_node::debug (void)
228 varpool_node::dump (stderr
);
231 /* Dump the variable pool to F. */
233 varpool_node::dump_varpool (FILE *f
)
237 fprintf (f
, "variable pool:\n\n");
238 FOR_EACH_VARIABLE (node
)
242 /* Dump the variable pool to stderr. */
245 varpool_node::debug_varpool (void)
247 dump_varpool (stderr
);
250 /* Given an assembler name, lookup node. */
252 varpool_node::get_for_asmname (tree asmname
)
254 if (symtab_node
*node
= symtab_node::get_for_asmname (asmname
))
255 return dyn_cast
<varpool_node
*> (node
);
260 /* When doing LTO, read variable's constructor from disk if
261 it is not already present. */
264 varpool_node::get_constructor (void)
266 lto_file_decl_data
*file_data
;
267 const char *data
, *name
;
270 if (DECL_INITIAL (decl
) != error_mark_node
272 return DECL_INITIAL (decl
);
274 timevar_push (TV_IPA_LTO_CTORS_IN
);
276 file_data
= lto_file_data
;
277 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
279 /* We may have renamed the declaration, e.g., a static function. */
280 name
= lto_get_decl_name_mapping (file_data
, name
);
282 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
285 fatal_error ("%s: section %s is missing",
286 file_data
->file_name
,
289 lto_input_variable_constructor (file_data
, this, data
);
290 lto_stats
.num_function_bodies
++;
291 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
293 lto_free_function_in_decl_state_for_node (this);
294 timevar_pop (TV_IPA_LTO_CTORS_IN
);
295 return DECL_INITIAL (decl
);
298 /* Return true if variable has constructor that can be used for folding. */
301 varpool_node::ctor_useable_for_folding_p (void)
303 varpool_node
*real_node
= this;
305 if (real_node
->alias
&& real_node
->definition
)
306 real_node
= ultimate_alias_target ();
308 if (TREE_CODE (decl
) == CONST_DECL
309 || DECL_IN_CONSTANT_POOL (decl
))
311 if (TREE_THIS_VOLATILE (decl
))
314 /* If we do not have a constructor, we can't use it. */
315 if (DECL_INITIAL (real_node
->decl
) == error_mark_node
316 && !real_node
->lto_file_data
)
319 /* Avoid attempts to load constructors that was not streamed. */
320 if (flag_ltrans
&& DECL_INITIAL (real_node
->decl
) == error_mark_node
321 && real_node
->body_removed
)
324 /* Vtables are defined by their types and must match no matter of interposition
326 if (DECL_VIRTUAL_P (decl
))
328 /* The C++ front end creates VAR_DECLs for vtables of typeinfo
329 classes not defined in the current TU so that it can refer
330 to them from typeinfo objects. Avoid returning NULL_TREE. */
331 return DECL_INITIAL (real_node
->decl
) != NULL
;
334 /* Alias of readonly variable is also readonly, since the variable is stored
335 in readonly memory. We also accept readonly aliases of non-readonly
336 locations assuming that user knows what he is asking for. */
337 if (!TREE_READONLY (decl
) && !TREE_READONLY (real_node
->decl
))
340 /* Variables declared 'const' without an initializer
341 have zero as the initializer if they may not be
342 overridden at link or run time.
344 It is actually requirement for C++ compiler to optimize const variables
345 consistently. As a GNU extension, do not enfore this rule for user defined
346 weak variables, so we support interposition on:
347 static const int dummy = 0;
348 extern const int foo __attribute__((__weak__, __alias__("dummy")));
350 if ((!DECL_INITIAL (real_node
->decl
)
351 || (DECL_WEAK (decl
) && !DECL_COMDAT (decl
)))
352 && (DECL_EXTERNAL (decl
) || decl_replaceable_p (decl
)))
355 /* Variables declared `const' with an initializer are considered
356 to not be overwritable with different initializer by default.
358 ??? Previously we behaved so for scalar variables but not for array
363 /* If DECLARATION is constant variable and its initial value is known
364 (so we can do constant folding), return its constructor (DECL_INITIAL).
365 This may be an expression or NULL when DECL is initialized to 0.
366 Return ERROR_MARK_NODE otherwise.
368 In LTO this may actually trigger reading the constructor from disk.
369 For this reason varpool_ctor_useable_for_folding_p should be used when
370 the actual constructor value is not needed. */
373 ctor_for_folding (tree decl
)
375 varpool_node
*node
, *real_node
;
378 if (TREE_CODE (decl
) != VAR_DECL
379 && TREE_CODE (decl
) != CONST_DECL
)
380 return error_mark_node
;
382 if (TREE_CODE (decl
) == CONST_DECL
383 || DECL_IN_CONSTANT_POOL (decl
))
384 return DECL_INITIAL (decl
);
386 if (TREE_THIS_VOLATILE (decl
))
387 return error_mark_node
;
389 /* Do not care about automatic variables. Those are never initialized
390 anyway, because gimplifier exapnds the code. */
391 if (!TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
393 gcc_assert (!TREE_PUBLIC (decl
));
394 return error_mark_node
;
397 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
399 real_node
= node
= varpool_node::get (decl
);
402 real_node
= node
->ultimate_alias_target ();
403 real_decl
= real_node
->decl
;
408 /* See if we are dealing with alias.
409 In most cases alias is just alternative symbol pointing to a given
410 constructor. This allows us to use interposition rules of DECL
411 constructor of REAL_NODE. However weakrefs are special by being just
412 alternative name of their target (if defined). */
413 if (decl
!= real_decl
)
415 gcc_assert (!DECL_INITIAL (decl
)
416 || (node
->alias
&& node
->get_alias_target () == real_node
)
417 || DECL_INITIAL (decl
) == error_mark_node
);
420 node
= node
->get_alias_target ();
425 if ((!DECL_VIRTUAL_P (real_decl
)
426 || DECL_INITIAL (real_decl
) == error_mark_node
427 || !DECL_INITIAL (real_decl
))
428 && (!node
|| !node
->ctor_useable_for_folding_p ()))
429 return error_mark_node
;
431 /* OK, we can return constructor. See if we need to fetch it from disk
433 if (DECL_INITIAL (real_decl
) != error_mark_node
435 return DECL_INITIAL (real_decl
);
436 return real_node
->get_constructor ();
439 /* Add the variable DECL to the varpool.
440 Unlike finalize_decl function is intended to be used
441 by middle end and allows insertion of new variable at arbitrary point
444 varpool_node::add (tree decl
)
447 varpool_node::finalize_decl (decl
);
448 node
= varpool_node::get_create (decl
);
449 symtab
->call_varpool_insertion_hooks (node
);
450 if (node
->externally_visible_p ())
451 node
->externally_visible
= true;
454 /* Return variable availability. See cgraph.h for description of individual
457 varpool_node::get_availability (void)
460 return AVAIL_NOT_AVAILABLE
;
461 if (!TREE_PUBLIC (decl
))
462 return AVAIL_AVAILABLE
;
463 if (DECL_IN_CONSTANT_POOL (decl
)
464 || DECL_VIRTUAL_P (decl
))
465 return AVAIL_AVAILABLE
;
466 if (alias
&& weakref
)
468 enum availability avail
;
470 ultimate_alias_target (&avail
)->get_availability ();
473 /* If the variable can be overwritten, return OVERWRITABLE. Takes
474 care of at least one notable extension - the COMDAT variables
475 used to share template instantiations in C++. */
476 if (decl_replaceable_p (decl
)
477 || DECL_EXTERNAL (decl
))
478 return AVAIL_INTERPOSABLE
;
479 return AVAIL_AVAILABLE
;
483 varpool_node::analyze (void)
485 /* When reading back varpool at LTO time, we re-construct the queue in order
486 to have "needed" list right by inserting all needed nodes into varpool.
487 We however don't want to re-analyze already analyzed nodes. */
490 gcc_assert (!in_lto_p
|| symtab
->function_flags_ready
);
491 /* Compute the alignment early so function body expanders are
492 already informed about increased alignment. */
493 align_variable (decl
, 0);
496 resolve_alias (varpool_node::get (alias_target
));
497 else if (DECL_INITIAL (decl
))
498 record_references_in_initializer (decl
, analyzed
);
502 /* Assemble thunks and aliases associated to varpool node. */
505 varpool_node::assemble_aliases (void)
509 FOR_EACH_ALIAS (this, ref
)
511 varpool_node
*alias
= dyn_cast
<varpool_node
*> (ref
->referring
);
512 do_assemble_alias (alias
->decl
,
513 DECL_ASSEMBLER_NAME (decl
));
514 alias
->assemble_aliases ();
518 /* Output one variable, if necessary. Return whether we output it. */
521 varpool_node::assemble_decl (void)
523 /* Aliases are outout when their target is produced or by
528 /* Constant pool is output from RTL land when the reference
529 survive till this level. */
530 if (DECL_IN_CONSTANT_POOL (decl
) && TREE_ASM_WRITTEN (decl
))
533 /* Decls with VALUE_EXPR should not be in the varpool at all. They
534 are not real variables, but just info for debugging and codegen.
535 Unfortunately at the moment emutls is not updating varpool correctly
536 after turning real vars into value_expr vars. */
537 if (DECL_HAS_VALUE_EXPR_P (decl
)
538 && !targetm
.have_tls
)
541 /* Hard register vars do not need to be output. */
542 if (DECL_HARD_REGISTER (decl
))
545 gcc_checking_assert (!TREE_ASM_WRITTEN (decl
)
546 && TREE_CODE (decl
) == VAR_DECL
547 && !DECL_HAS_VALUE_EXPR_P (decl
));
549 if (!in_other_partition
550 && !DECL_EXTERNAL (decl
))
553 assemble_variable (decl
, 0, 1, 0);
554 gcc_assert (TREE_ASM_WRITTEN (decl
));
555 gcc_assert (definition
);
563 /* Add NODE to queue starting at FIRST.
564 The queue is linked via AUX pointers and terminated by pointer to 1. */
567 enqueue_node (varpool_node
*node
, varpool_node
**first
)
571 gcc_checking_assert (*first
);
576 /* Optimization of function bodies might've rendered some variables as
577 unnecessary so we want to avoid these from being compiled. Re-do
578 reachability starting from variables that are either externally visible
579 or was referred from the asm output routines. */
582 symbol_table::remove_unreferenced_decls (void)
584 varpool_node
*next
, *node
;
585 varpool_node
*first
= (varpool_node
*)(void *)1;
588 hash_set
<varpool_node
*> referenced
;
594 fprintf (dump_file
, "Trivially needed variables:");
595 FOR_EACH_DEFINED_VARIABLE (node
)
598 && (!node
->can_remove_if_no_refs_p ()
599 /* We just expanded all function bodies. See if any of
600 them needed the variable. */
601 || DECL_RTL_SET_P (node
->decl
)))
603 enqueue_node (node
, &first
);
605 fprintf (dump_file
, " %s", node
->asm_name ());
608 while (first
!= (varpool_node
*)(void *)1)
611 first
= (varpool_node
*)first
->aux
;
613 if (node
->same_comdat_group
)
616 for (next
= node
->same_comdat_group
;
618 next
= next
->same_comdat_group
)
620 varpool_node
*vnext
= dyn_cast
<varpool_node
*> (next
);
621 if (vnext
&& vnext
->analyzed
&& !next
->comdat_local_p ())
622 enqueue_node (vnext
, &first
);
625 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
627 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (ref
->referred
);
629 && !vnode
->in_other_partition
630 && (!DECL_EXTERNAL (ref
->referred
->decl
)
633 enqueue_node (vnode
, &first
);
635 referenced
.add (node
);
639 fprintf (dump_file
, "\nRemoving variables:");
640 for (node
= first_defined_variable (); node
; node
= next
)
642 next
= next_defined_variable (node
);
646 fprintf (dump_file
, " %s", node
->asm_name ());
647 if (referenced
.contains(node
))
648 node
->remove_initializer ();
655 fprintf (dump_file
, "\n");
658 /* For variables in named sections make sure get_variable_section
659 is called before we switch to those sections. Then section
660 conflicts between read-only and read-only requiring relocations
661 sections can be resolved. */
663 varpool_node::finalize_named_section_flags (void)
665 if (!TREE_ASM_WRITTEN (decl
)
667 && !in_other_partition
668 && !DECL_EXTERNAL (decl
)
669 && TREE_CODE (decl
) == VAR_DECL
670 && !DECL_HAS_VALUE_EXPR_P (decl
)
672 get_variable_section (decl
, false);
675 /* Output all variables enqueued to be assembled. */
677 symbol_table::output_variables (void)
679 bool changed
= false;
685 remove_unreferenced_decls ();
687 timevar_push (TV_VAROUT
);
689 FOR_EACH_DEFINED_VARIABLE (node
)
690 node
->finalize_named_section_flags ();
692 FOR_EACH_DEFINED_VARIABLE (node
)
693 if (node
->assemble_decl ())
695 timevar_pop (TV_VAROUT
);
699 /* Create a new global variable of type TYPE. */
701 add_new_static_var (tree type
)
704 varpool_node
*new_node
;
706 new_decl
= create_tmp_var_raw (type
, NULL
);
707 DECL_NAME (new_decl
) = create_tmp_var_name (NULL
);
708 TREE_READONLY (new_decl
) = 0;
709 TREE_STATIC (new_decl
) = 1;
710 TREE_USED (new_decl
) = 1;
711 DECL_CONTEXT (new_decl
) = NULL_TREE
;
712 DECL_ABSTRACT (new_decl
) = 0;
713 lang_hooks
.dup_lang_specific_decl (new_decl
);
714 new_node
= varpool_node::get_create (new_decl
);
715 varpool_node::finalize_decl (new_decl
);
717 return new_node
->decl
;
720 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
721 Extra name aliases are output whenever DECL is output. */
724 varpool_node::create_alias (tree alias
, tree decl
)
726 varpool_node
*alias_node
;
728 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
729 gcc_assert (TREE_CODE (alias
) == VAR_DECL
);
730 alias_node
= varpool_node::get_create (alias
);
731 alias_node
->alias
= true;
732 alias_node
->definition
= true;
733 alias_node
->alias_target
= decl
;
734 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias
)) != NULL
)
735 alias_node
->weakref
= true;
739 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
740 Extra name aliases are output whenever DECL is output. */
743 varpool_node::create_extra_name_alias (tree alias
, tree decl
)
745 varpool_node
*alias_node
;
747 #ifndef ASM_OUTPUT_DEF
748 /* If aliases aren't supported by the assembler, fail. */
751 alias_node
= varpool_node::create_alias (alias
, decl
);
752 alias_node
->cpp_implicit_alias
= true;
754 /* Extra name alias mechanizm creates aliases really late
755 via DECL_ASSEMBLER_NAME mechanizm.
756 This is unfortunate because they are not going through the
757 standard channels. Ensure they get output. */
758 if (symtab
->cpp_implicit_aliases_done
)
759 alias_node
->resolve_alias (varpool_node::get_create (decl
));
763 /* Call calback on varpool symbol and aliases associated to varpool symbol.
764 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
768 varpool_node::call_for_node_and_aliases (bool (*callback
) (varpool_node
*,
771 bool include_overwritable
)
775 if (callback (this, data
))
778 FOR_EACH_ALIAS (this, ref
)
780 varpool_node
*alias
= dyn_cast
<varpool_node
*> (ref
->referring
);
781 if (include_overwritable
782 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
783 if (alias
->call_for_node_and_aliases (callback
, data
,
784 include_overwritable
))