1 /* Basic IPA optimizations and utilities.
2 Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
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"
26 #include "tree-pass.h"
31 #include "pointer-set.h"
33 #include "tree-iterator.h"
34 #include "ipa-utils.h"
36 /* Look for all functions inlined to NODE and update their inlined_to pointers
40 update_inlined_to_pointer (struct cgraph_node
*node
, struct cgraph_node
*inlined_to
)
42 struct cgraph_edge
*e
;
43 for (e
= node
->callees
; e
; e
= e
->next_callee
)
44 if (e
->callee
->global
.inlined_to
)
46 e
->callee
->global
.inlined_to
= inlined_to
;
47 update_inlined_to_pointer (e
->callee
, inlined_to
);
51 /* Add cgraph NODE to queue starting at FIRST.
53 The queue is linked via AUX pointers and terminated by pointer to 1.
54 We enqueue nodes at two occasions: when we find them reachable or when we find
55 their bodies needed for further clonning. In the second case we mark them
56 by pointer to 2 after processing so they are re-queue when they become
60 enqueue_cgraph_node (struct cgraph_node
*node
, struct cgraph_node
**first
)
62 /* Node is still in queue; do nothing. */
63 if (node
->aux
&& node
->aux
!= (void *) 2)
65 /* Node was already processed as unreachable, re-enqueue
66 only if it became reachable now. */
67 if (node
->aux
== (void *)2 && !node
->reachable
)
73 /* Add varpool NODE to queue starting at FIRST. */
76 enqueue_varpool_node (struct varpool_node
*node
, struct varpool_node
**first
)
82 /* Process references. */
85 process_references (struct ipa_ref_list
*list
,
86 struct cgraph_node
**first
,
87 struct varpool_node
**first_varpool
,
88 bool before_inlining_p
)
92 for (i
= 0; ipa_ref_list_reference_iterate (list
, i
, ref
); i
++)
94 if (ref
->refered_type
== IPA_REF_CGRAPH
)
96 struct cgraph_node
*node
= ipa_ref_node (ref
);
99 && (!DECL_EXTERNAL (node
->decl
)
100 || before_inlining_p
))
101 node
->reachable
= true;
102 enqueue_cgraph_node (node
, first
);
106 struct varpool_node
*node
= ipa_ref_varpool_node (ref
);
109 varpool_mark_needed_node (node
);
110 enqueue_varpool_node (node
, first_varpool
);
117 /* Return true when NODE can not be local. Worker for cgraph_local_node_p. */
120 cgraph_non_local_node_p_1 (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
122 /* FIXME: Aliases can be local, but i386 gets thunks wrong then. */
123 return !(cgraph_only_called_directly_or_aliased_p (node
)
124 && !ipa_ref_has_aliases_p (&node
->ref_list
)
126 && !DECL_EXTERNAL (node
->decl
)
127 && !node
->local
.externally_visible
128 && !node
->reachable_from_other_partition
129 && !node
->in_other_partition
);
132 /* Return true when function can be marked local. */
135 cgraph_local_node_p (struct cgraph_node
*node
)
137 struct cgraph_node
*n
= cgraph_function_or_thunk_node (node
, NULL
);
139 /* FIXME: thunks can be considered local, but we need prevent i386
140 from attempting to change calling convention of them. */
141 if (n
->thunk
.thunk_p
)
143 return !cgraph_for_node_and_aliases (n
,
144 cgraph_non_local_node_p_1
, NULL
, true);
148 /* Return true when NODE has ADDR reference. */
151 has_addr_references_p (struct cgraph_node
*node
,
152 void *data ATTRIBUTE_UNUSED
)
157 for (i
= 0; ipa_ref_list_refering_iterate (&node
->ref_list
, i
, ref
); i
++)
158 if (ref
->use
== IPA_REF_ADDR
)
163 /* Perform reachability analysis and reclaim all unreachable nodes.
164 If BEFORE_INLINING_P is true this function is called before inlining
165 decisions has been made. If BEFORE_INLINING_P is false this function also
166 removes unneeded bodies of extern inline functions. */
169 cgraph_remove_unreachable_nodes (bool before_inlining_p
, FILE *file
)
171 struct cgraph_node
*first
= (struct cgraph_node
*) (void *) 1;
172 struct varpool_node
*first_varpool
= (struct varpool_node
*) (void *) 1;
173 struct cgraph_node
*node
, *next
;
174 struct varpool_node
*vnode
, *vnext
;
175 bool changed
= false;
177 #ifdef ENABLE_CHECKING
181 fprintf (file
, "\nReclaiming functions:");
182 #ifdef ENABLE_CHECKING
183 for (node
= cgraph_nodes
; node
; node
= node
->next
)
184 gcc_assert (!node
->aux
);
185 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
186 gcc_assert (!vnode
->aux
);
188 varpool_reset_queue ();
189 /* Mark functions whose bodies are obviously needed.
190 This is mostly when they can be referenced externally. Inline clones
191 are special since their declarations are shared with master clone and thus
192 cgraph_can_remove_if_no_direct_calls_and_refs_p should not be called on them. */
193 for (node
= cgraph_nodes
; node
; node
= node
->next
)
194 if (node
->analyzed
&& !node
->global
.inlined_to
195 && (!cgraph_can_remove_if_no_direct_calls_and_refs_p (node
)
196 /* Keep around virtual functions for possible devirtualization. */
197 || (before_inlining_p
198 && DECL_VIRTUAL_P (node
->decl
)
199 && (DECL_COMDAT (node
->decl
) || DECL_EXTERNAL (node
->decl
)))
200 /* Also external functions with address taken are better to stay
201 for indirect inlining. */
202 || (before_inlining_p
203 && DECL_EXTERNAL (node
->decl
)
204 && node
->address_taken
)))
206 gcc_assert (!node
->global
.inlined_to
);
207 enqueue_cgraph_node (node
, &first
);
208 node
->reachable
= true;
212 gcc_assert (!node
->aux
);
213 node
->reachable
= false;
216 /* Mark variables that are obviously needed. */
217 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
219 vnode
->next_needed
= NULL
;
220 vnode
->prev_needed
= NULL
;
221 if ((vnode
->analyzed
|| vnode
->force_output
)
222 && !varpool_can_remove_if_no_refs (vnode
))
224 vnode
->needed
= false;
225 varpool_mark_needed_node (vnode
);
226 enqueue_varpool_node (vnode
, &first_varpool
);
229 vnode
->needed
= false;
232 /* Perform reachability analysis. As a special case do not consider
233 extern inline functions not inlined as live because we won't output
236 We maintain two worklist, one for cgraph nodes other for varpools and
237 are finished once both are empty. */
239 while (first
!= (struct cgraph_node
*) (void *) 1
240 || first_varpool
!= (struct varpool_node
*) (void *) 1)
242 if (first
!= (struct cgraph_node
*) (void *) 1)
244 struct cgraph_edge
*e
;
246 first
= (struct cgraph_node
*) first
->aux
;
247 if (!node
->reachable
)
248 node
->aux
= (void *)2;
250 /* If we found this node reachable, first mark on the callees
251 reachable too, unless they are direct calls to extern inline functions
252 we decided to not inline. */
255 for (e
= node
->callees
; e
; e
= e
->next_callee
)
257 if (!e
->callee
->reachable
259 && (!e
->inline_failed
260 || !DECL_EXTERNAL (e
->callee
->decl
)
261 || before_inlining_p
))
262 e
->callee
->reachable
= true;
263 enqueue_cgraph_node (e
->callee
, &first
);
265 process_references (&node
->ref_list
, &first
, &first_varpool
, before_inlining_p
);
268 /* If any function in a comdat group is reachable, force
269 all other functions in the same comdat group to be
271 if (node
->same_comdat_group
273 && !node
->global
.inlined_to
)
275 for (next
= node
->same_comdat_group
;
277 next
= next
->same_comdat_group
)
278 if (!next
->reachable
)
280 next
->reachable
= true;
281 enqueue_cgraph_node (next
, &first
);
285 /* We can freely remove inline clones even if they are cloned, however if
286 function is clone of real clone, we must keep it around in order to
287 make materialize_clones produce function body with the changes
289 while (node
->clone_of
&& !node
->clone_of
->aux
290 && !gimple_has_body_p (node
->decl
))
292 bool noninline
= node
->clone_of
->decl
!= node
->decl
;
293 node
= node
->clone_of
;
294 if (noninline
&& !node
->reachable
&& !node
->aux
)
296 enqueue_cgraph_node (node
, &first
);
301 if (first_varpool
!= (struct varpool_node
*) (void *) 1)
303 vnode
= first_varpool
;
304 first_varpool
= (struct varpool_node
*)first_varpool
->aux
;
306 process_references (&vnode
->ref_list
, &first
, &first_varpool
, before_inlining_p
);
307 /* If any function in a comdat group is reachable, force
308 all other functions in the same comdat group to be
310 if (vnode
->same_comdat_group
)
312 struct varpool_node
*next
;
313 for (next
= vnode
->same_comdat_group
;
315 next
= next
->same_comdat_group
)
318 varpool_mark_needed_node (next
);
319 enqueue_varpool_node (next
, &first_varpool
);
325 /* Remove unreachable nodes.
327 Completely unreachable functions can be fully removed from the callgraph.
328 Extern inline functions that we decided to not inline need to become unanalyzed nodes of
329 callgraph (so we still have edges to them). We remove function body then.
331 Also we need to care functions that are unreachable but we need to keep them around
332 for later clonning. In this case we also turn them to unanalyzed nodes, but
333 keep the body around. */
334 for (node
= cgraph_nodes
; node
; node
= next
)
337 if (node
->aux
&& !node
->reachable
)
339 cgraph_node_remove_callees (node
);
340 ipa_remove_all_references (&node
->ref_list
);
341 node
->analyzed
= false;
345 struct cgraph_edge
*e
;
350 node
->global
.inlined_to
= NULL
;
352 fprintf (file
, " %s", cgraph_node_name (node
));
353 /* See if there is reachable caller. */
354 for (e
= node
->callers
; e
&& !found
; e
= e
->next_caller
)
355 if (e
->caller
->reachable
)
357 for (i
= 0; (ipa_ref_list_refering_iterate (&node
->ref_list
, i
, ref
)
359 if (ref
->refering_type
== IPA_REF_CGRAPH
360 && ipa_ref_refering_node (ref
)->reachable
)
362 else if (ref
->refering_type
== IPA_REF_VARPOOL
363 && ipa_ref_refering_varpool_node (ref
)->needed
)
366 /* If so, we need to keep node in the callgraph. */
371 struct cgraph_node
*clone
;
373 /* If there are still clones, we must keep body around.
374 Otherwise we can just remove the body but keep the clone. */
375 for (clone
= node
->clones
; clone
;
376 clone
= clone
->next_sibling_clone
)
381 cgraph_release_function_body (node
);
382 if (node
->prev_sibling_clone
)
383 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
384 else if (node
->clone_of
)
385 node
->clone_of
->clones
= node
->next_sibling_clone
;
386 if (node
->next_sibling_clone
)
387 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
389 node
->former_clone_of
= node
->clone_of
->decl
;
390 node
->clone_of
= NULL
;
391 node
->next_sibling_clone
= NULL
;
392 node
->prev_sibling_clone
= NULL
;
395 gcc_assert (!clone
->in_other_partition
);
396 node
->analyzed
= false;
398 cgraph_node_remove_callees (node
);
399 ipa_remove_all_references (&node
->ref_list
);
404 cgraph_remove_node (node
);
409 for (node
= cgraph_nodes
; node
; node
= node
->next
)
411 /* Inline clones might be kept around so their materializing allows further
412 cloning. If the function the clone is inlined into is removed, we need
413 to turn it into normal cone. */
414 if (node
->global
.inlined_to
417 gcc_assert (node
->clones
);
418 node
->global
.inlined_to
= NULL
;
419 update_inlined_to_pointer (node
, node
);
425 fprintf (file
, "\n");
427 /* We must release unused extern inlines or sanity checking will fail. Rest of transformations
428 are undesirable at -O0 since we do not want to remove anything. */
433 fprintf (file
, "Reclaiming variables:");
434 for (vnode
= varpool_nodes
; vnode
; vnode
= vnext
)
440 fprintf (file
, " %s", varpool_node_name (vnode
));
441 varpool_remove_node (vnode
);
446 /* Now update address_taken flags and try to promote functions to be local. */
449 fprintf (file
, "\nClearing address taken flags:");
450 for (node
= cgraph_nodes
; node
; node
= node
->next
)
451 if (node
->address_taken
452 && !node
->reachable_from_other_partition
)
454 if (!cgraph_for_node_and_aliases (node
, has_addr_references_p
, NULL
, true))
457 fprintf (file
, " %s", cgraph_node_name (node
));
458 node
->address_taken
= false;
460 if (cgraph_local_node_p (node
))
462 node
->local
.local
= true;
464 fprintf (file
, " (local)");
469 fprintf (file
, "\n");
471 #ifdef ENABLE_CHECKING
475 /* Reclaim alias pairs for functions that have disappeared from the
477 remove_unreachable_alias_pairs ();
482 /* Discover variables that have no longer address taken or that are read only
483 and update their flags.
485 FIXME: This can not be done in between gimplify and omp_expand since
486 readonly flag plays role on what is shared and what is not. Currently we do
487 this transformation as part of whole program visibility and re-do at
488 ipa-reference pass (to take into account clonning), but it would
489 make sense to do it before early optimizations. */
492 ipa_discover_readonly_nonaddressable_vars (void)
494 struct varpool_node
*vnode
;
496 fprintf (dump_file
, "Clearing variable flags:");
497 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
498 if (vnode
->finalized
&& varpool_all_refs_explicit_p (vnode
)
499 && (TREE_ADDRESSABLE (vnode
->decl
) || !TREE_READONLY (vnode
->decl
)))
501 bool written
= false;
502 bool address_taken
= false;
505 for (i
= 0; ipa_ref_list_refering_iterate (&vnode
->ref_list
, i
, ref
)
506 && (!written
|| !address_taken
); i
++)
510 address_taken
= true;
518 if (TREE_ADDRESSABLE (vnode
->decl
) && !address_taken
)
521 fprintf (dump_file
, " %s (addressable)", varpool_node_name (vnode
));
522 TREE_ADDRESSABLE (vnode
->decl
) = 0;
524 if (!TREE_READONLY (vnode
->decl
) && !address_taken
&& !written
525 /* Making variable in explicit section readonly can cause section
527 See e.g. gcc.c-torture/compile/pr23237.c */
528 && DECL_SECTION_NAME (vnode
->decl
) == NULL
)
531 fprintf (dump_file
, " %s (read-only)", varpool_node_name (vnode
));
532 TREE_READONLY (vnode
->decl
) = 1;
536 fprintf (dump_file
, "\n");
539 /* Return true when there is a reference to node and it is not vtable. */
541 cgraph_address_taken_from_non_vtable_p (struct cgraph_node
*node
)
545 for (i
= 0; ipa_ref_list_reference_iterate (&node
->ref_list
, i
, ref
); i
++)
547 struct varpool_node
*node
;
548 if (ref
->refered_type
== IPA_REF_CGRAPH
)
550 node
= ipa_ref_varpool_node (ref
);
551 if (!DECL_VIRTUAL_P (node
->decl
))
557 /* COMDAT functions must be shared only if they have address taken,
558 otherwise we can produce our own private implementation with
560 Return true when turning COMDAT functoin static can not lead to wrong
561 code when the resulting object links with a library defining same COMDAT.
563 Virtual functions do have their addresses taken from the vtables,
564 but in C++ there is no way to compare their addresses for equality. */
567 cgraph_comdat_can_be_unshared_p (struct cgraph_node
*node
)
569 if ((cgraph_address_taken_from_non_vtable_p (node
)
570 && !DECL_VIRTUAL_P (node
->decl
))
573 if (node
->same_comdat_group
)
575 struct cgraph_node
*next
;
577 /* If more than one function is in the same COMDAT group, it must
578 be shared even if just one function in the comdat group has
580 for (next
= node
->same_comdat_group
;
581 next
!= node
; next
= next
->same_comdat_group
)
582 if (cgraph_address_taken_from_non_vtable_p (next
)
583 && !DECL_VIRTUAL_P (next
->decl
))
589 /* Return true when function NODE should be considered externally visible. */
592 cgraph_externally_visible_p (struct cgraph_node
*node
,
593 bool whole_program
, bool aliased
)
595 if (!node
->local
.finalized
)
597 if (!DECL_COMDAT (node
->decl
)
598 && (!TREE_PUBLIC (node
->decl
) || DECL_EXTERNAL (node
->decl
)))
601 /* Do not even try to be smart about aliased nodes. Until we properly
602 represent everything by same body alias, these are just evil. */
606 /* Do not try to localize built-in functions yet. One of problems is that we
607 end up mangling their asm for WHOPR that makes it impossible to call them
608 using the implicit built-in declarations anymore. Similarly this enables
609 us to remove them as unreachable before actual calls may appear during
610 expansion or folding. */
611 if (DECL_BUILT_IN (node
->decl
))
614 /* FIXME: We get wrong symbols with asm aliases in callgraph and LTO.
615 This is because very little of code knows that assembler name needs to
616 mangled. Avoid touching declarations with user asm name set to mask
617 some of the problems. */
618 if (DECL_ASSEMBLER_NAME_SET_P (node
->decl
)
619 && IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node
->decl
))[0]=='*')
622 /* If linker counts on us, we must preserve the function. */
623 if (cgraph_used_from_object_file_p (node
))
625 if (DECL_PRESERVE_P (node
->decl
))
627 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (node
->decl
)))
629 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
630 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (node
->decl
)))
632 if (node
->resolution
== LDPR_PREVAILING_DEF_IRONLY
)
634 /* When doing LTO or whole program, we can bring COMDAT functoins static.
635 This improves code quality and we know we will duplicate them at most twice
636 (in the case that we are not using plugin and link with object file
637 implementing same COMDAT) */
638 if ((in_lto_p
|| whole_program
)
639 && DECL_COMDAT (node
->decl
)
640 && cgraph_comdat_can_be_unshared_p (node
))
643 /* When doing link time optimizations, hidden symbols become local. */
645 && (DECL_VISIBILITY (node
->decl
) == VISIBILITY_HIDDEN
646 || DECL_VISIBILITY (node
->decl
) == VISIBILITY_INTERNAL
)
647 /* Be sure that node is defined in IR file, not in other object
648 file. In that case we don't set used_from_other_object_file. */
651 else if (!whole_program
)
654 if (MAIN_NAME_P (DECL_NAME (node
->decl
)))
660 /* Return true when variable VNODE should be considered externally visible. */
663 varpool_externally_visible_p (struct varpool_node
*vnode
, bool aliased
)
665 struct varpool_node
*alias
;
666 if (!DECL_COMDAT (vnode
->decl
) && !TREE_PUBLIC (vnode
->decl
))
669 /* Do not even try to be smart about aliased nodes. Until we properly
670 represent everything by same body alias, these are just evil. */
674 /* If linker counts on us, we must preserve the function. */
675 if (varpool_used_from_object_file_p (vnode
))
678 /* FIXME: We get wrong symbols with asm aliases in callgraph and LTO.
679 This is because very little of code knows that assembler name needs to
680 mangled. Avoid touching declarations with user asm name set to mask
681 some of the problems. */
682 if (DECL_ASSEMBLER_NAME_SET_P (vnode
->decl
)
683 && IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (vnode
->decl
))[0]=='*')
686 if (DECL_PRESERVE_P (vnode
->decl
))
688 if (lookup_attribute ("externally_visible",
689 DECL_ATTRIBUTES (vnode
->decl
)))
691 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
692 && lookup_attribute ("dllexport",
693 DECL_ATTRIBUTES (vnode
->decl
)))
696 /* See if we have linker information about symbol not being used or
697 if we need to make guess based on the declaration.
699 Even if the linker clams the symbol is unused, never bring internal
700 symbols that are declared by user as used or externally visible.
701 This is needed for i.e. references from asm statements. */
702 if (varpool_used_from_object_file_p (vnode
))
704 for (alias
= vnode
->extra_name
; alias
; alias
= alias
->next
)
705 if (alias
->resolution
!= LDPR_PREVAILING_DEF_IRONLY
)
707 if (!alias
&& vnode
->resolution
== LDPR_PREVAILING_DEF_IRONLY
)
710 /* As a special case, the COMDAT virutal tables can be unshared.
711 In LTO mode turn vtables into static variables. The variable is readonly,
712 so this does not enable more optimization, but referring static var
713 is faster for dynamic linking. Also this match logic hidding vtables
714 from LTO symbol tables. */
715 if ((in_lto_p
|| flag_whole_program
)
716 && !vnode
->force_output
717 && DECL_COMDAT (vnode
->decl
) && DECL_VIRTUAL_P (vnode
->decl
))
720 /* When doing link time optimizations, hidden symbols become local. */
722 && (DECL_VISIBILITY (vnode
->decl
) == VISIBILITY_HIDDEN
723 || DECL_VISIBILITY (vnode
->decl
) == VISIBILITY_INTERNAL
)
724 /* Be sure that node is defined in IR file, not in other object
725 file. In that case we don't set used_from_other_object_file. */
728 else if (!flag_whole_program
)
731 /* Do not attempt to privatize COMDATS by default.
732 This would break linking with C++ libraries sharing
735 FIXME: We can do so for readonly vars with no address taken and
736 possibly also for vtables since no direct pointer comparsion is done.
737 It might be interesting to do so to reduce linking overhead. */
738 if (DECL_COMDAT (vnode
->decl
) || DECL_WEAK (vnode
->decl
))
743 /* Dissolve the same_comdat_group list in which NODE resides. */
746 dissolve_same_comdat_group_list (struct cgraph_node
*node
)
748 struct cgraph_node
*n
= node
, *next
;
751 next
= n
->same_comdat_group
;
752 n
->same_comdat_group
= NULL
;
758 /* Mark visibility of all functions.
760 A local function is one whose calls can occur only in the current
761 compilation unit and all its calls are explicit, so we can change
762 its calling convention. We simply mark all static functions whose
763 address is not taken as local.
765 We also change the TREE_PUBLIC flag of all declarations that are public
766 in language point of view but we want to overwrite this default
767 via visibilities for the backend point of view. */
770 function_and_variable_visibility (bool whole_program
)
772 struct cgraph_node
*node
;
773 struct varpool_node
*vnode
;
774 struct pointer_set_t
*aliased_nodes
= pointer_set_create ();
775 struct pointer_set_t
*aliased_vnodes
= pointer_set_create ();
779 /* Discover aliased nodes. */
780 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
783 fprintf (dump_file
, "Alias %s->%s",
784 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (p
->decl
)),
785 IDENTIFIER_POINTER (p
->target
));
787 if ((node
= cgraph_node_for_asm (p
->target
)) != NULL
788 && !DECL_EXTERNAL (node
->decl
))
792 /* Weakrefs alias symbols from other compilation unit. In the case
793 the destination of weakref became available because of LTO, we must
794 mark it as needed. */
796 && lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
))
798 cgraph_mark_needed_node (node
);
799 gcc_assert (node
->needed
);
800 pointer_set_insert (aliased_nodes
, node
);
802 fprintf (dump_file
, " node %s/%i",
803 cgraph_node_name (node
), node
->uid
);
805 else if ((vnode
= varpool_node_for_asm (p
->target
)) != NULL
806 && !DECL_EXTERNAL (vnode
->decl
))
808 /* Weakrefs alias symbols from other compilation unit. In the case
809 the destination of weakref became available because of LTO, we must
810 mark it as needed. */
812 && lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
))
814 varpool_mark_needed_node (vnode
);
815 gcc_assert (vnode
->needed
);
816 pointer_set_insert (aliased_vnodes
, vnode
);
818 fprintf (dump_file
, " varpool node %s",
819 varpool_node_name (vnode
));
822 fprintf (dump_file
, "\n");
825 for (node
= cgraph_nodes
; node
; node
= node
->next
)
827 int flags
= flags_from_decl_or_type (node
->decl
);
829 /* Optimize away PURE and CONST constructors and destructors. */
831 && (flags
& (ECF_CONST
| ECF_PURE
))
832 && !(flags
& ECF_LOOPING_CONST_OR_PURE
))
834 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
835 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
838 /* Frontends and alias code marks nodes as needed before parsing is finished.
839 We may end up marking as node external nodes where this flag is meaningless
842 && (DECL_EXTERNAL (node
->decl
) || !node
->analyzed
))
845 /* C++ FE on lack of COMDAT support create local COMDAT functions
846 (that ought to be shared but can not due to object format
847 limitations). It is neccesary to keep the flag to make rest of C++ FE
848 happy. Clear the flag here to avoid confusion in middle-end. */
849 if (DECL_COMDAT (node
->decl
) && !TREE_PUBLIC (node
->decl
))
850 DECL_COMDAT (node
->decl
) = 0;
851 /* For external decls stop tracking same_comdat_group, it doesn't matter
852 what comdat group they are in when they won't be emitted in this TU,
853 and simplifies later passes. */
854 if (node
->same_comdat_group
&& DECL_EXTERNAL (node
->decl
))
856 #ifdef ENABLE_CHECKING
857 struct cgraph_node
*n
;
859 for (n
= node
->same_comdat_group
;
861 n
= n
->same_comdat_group
)
862 /* If at least one of same comdat group functions is external,
863 all of them have to be, otherwise it is a front-end bug. */
864 gcc_assert (DECL_EXTERNAL (n
->decl
));
866 dissolve_same_comdat_group_list (node
);
868 gcc_assert ((!DECL_WEAK (node
->decl
) && !DECL_COMDAT (node
->decl
))
869 || TREE_PUBLIC (node
->decl
) || DECL_EXTERNAL (node
->decl
));
870 if (cgraph_externally_visible_p (node
, whole_program
,
871 pointer_set_contains (aliased_nodes
,
874 gcc_assert (!node
->global
.inlined_to
);
875 node
->local
.externally_visible
= true;
878 node
->local
.externally_visible
= false;
879 if (!node
->local
.externally_visible
&& node
->analyzed
880 && !DECL_EXTERNAL (node
->decl
))
882 gcc_assert (whole_program
|| in_lto_p
|| !TREE_PUBLIC (node
->decl
));
883 cgraph_make_decl_local (node
->decl
);
884 node
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
885 if (node
->same_comdat_group
)
886 /* cgraph_externally_visible_p has already checked all other nodes
887 in the group and they will all be made local. We need to
888 dissolve the group at once so that the predicate does not
890 dissolve_same_comdat_group_list (node
);
893 if (node
->thunk
.thunk_p
894 && TREE_PUBLIC (node
->decl
))
896 struct cgraph_node
*decl_node
= node
;
898 decl_node
= cgraph_function_node (decl_node
->callees
->callee
, NULL
);
900 /* Thunks have the same visibility as function they are attached to.
901 For some reason C++ frontend don't seem to care. I.e. in
902 g++.dg/torture/pr41257-2.C the thunk is not comdat while function
903 it is attached to is.
905 We also need to arrange the thunk into the same comdat group as
906 the function it reffers to. */
907 if (DECL_ONE_ONLY (decl_node
->decl
))
909 DECL_COMDAT (node
->decl
) = DECL_COMDAT (decl_node
->decl
);
910 DECL_COMDAT_GROUP (node
->decl
) = DECL_COMDAT_GROUP (decl_node
->decl
);
911 if (DECL_ONE_ONLY (decl_node
->decl
) && !node
->same_comdat_group
)
913 node
->same_comdat_group
= decl_node
;
914 if (!decl_node
->same_comdat_group
)
915 decl_node
->same_comdat_group
= node
;
918 struct cgraph_node
*n
;
919 for (n
= decl_node
->same_comdat_group
;
920 n
->same_comdat_group
!= decl_node
;
921 n
= n
->same_comdat_group
)
923 n
->same_comdat_group
= node
;
927 if (DECL_EXTERNAL (decl_node
->decl
))
928 DECL_EXTERNAL (node
->decl
) = 1;
931 for (node
= cgraph_nodes
; node
; node
= node
->next
)
932 node
->local
.local
= cgraph_local_node_p (node
);
933 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
935 /* weak flag makes no sense on local variables. */
936 gcc_assert (!DECL_WEAK (vnode
->decl
)
937 || TREE_PUBLIC (vnode
->decl
) || DECL_EXTERNAL (vnode
->decl
));
938 /* In several cases declarations can not be common:
940 - when declaration has initializer
942 - when it has specific section
943 - when it resides in non-generic address space.
944 - if declaration is local, it will get into .local common section
945 so common flag is not needed. Frontends still produce these in
946 certain cases, such as for:
948 static int a __attribute__ ((common))
950 Canonicalize things here and clear the redundant flag. */
951 if (DECL_COMMON (vnode
->decl
)
952 && (!(TREE_PUBLIC (vnode
->decl
) || DECL_EXTERNAL (vnode
->decl
))
953 || (DECL_INITIAL (vnode
->decl
)
954 && DECL_INITIAL (vnode
->decl
) != error_mark_node
)
955 || DECL_WEAK (vnode
->decl
)
956 || DECL_SECTION_NAME (vnode
->decl
) != NULL
957 || ! (ADDR_SPACE_GENERIC_P
958 (TYPE_ADDR_SPACE (TREE_TYPE (vnode
->decl
))))))
959 DECL_COMMON (vnode
->decl
) = 0;
961 for (vnode
= varpool_nodes_queue
; vnode
; vnode
= vnode
->next_needed
)
963 if (!vnode
->finalized
)
966 && varpool_externally_visible_p
968 pointer_set_contains (aliased_vnodes
, vnode
)))
969 vnode
->externally_visible
= true;
971 vnode
->externally_visible
= false;
972 if (!vnode
->externally_visible
)
974 gcc_assert (in_lto_p
|| whole_program
|| !TREE_PUBLIC (vnode
->decl
));
975 cgraph_make_decl_local (vnode
->decl
);
976 vnode
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
978 gcc_assert (TREE_STATIC (vnode
->decl
));
980 pointer_set_destroy (aliased_nodes
);
981 pointer_set_destroy (aliased_vnodes
);
985 fprintf (dump_file
, "\nMarking local functions:");
986 for (node
= cgraph_nodes
; node
; node
= node
->next
)
987 if (node
->local
.local
)
988 fprintf (dump_file
, " %s", cgraph_node_name (node
));
989 fprintf (dump_file
, "\n\n");
990 fprintf (dump_file
, "\nMarking externally visible functions:");
991 for (node
= cgraph_nodes
; node
; node
= node
->next
)
992 if (node
->local
.externally_visible
)
993 fprintf (dump_file
, " %s", cgraph_node_name (node
));
994 fprintf (dump_file
, "\n\n");
995 fprintf (dump_file
, "\nMarking externally visible variables:");
996 for (vnode
= varpool_nodes_queue
; vnode
; vnode
= vnode
->next_needed
)
997 if (vnode
->externally_visible
)
998 fprintf (dump_file
, " %s", varpool_node_name (vnode
));
999 fprintf (dump_file
, "\n\n");
1001 cgraph_function_flags_ready
= true;
1005 /* Local function pass handling visibilities. This happens before LTO streaming
1006 so in particular -fwhole-program should be ignored at this level. */
1009 local_function_and_variable_visibility (void)
1011 return function_and_variable_visibility (flag_whole_program
&& !flag_lto
);
1014 struct simple_ipa_opt_pass pass_ipa_function_and_variable_visibility
=
1018 "visibility", /* name */
1020 local_function_and_variable_visibility
,/* execute */
1023 0, /* static_pass_number */
1024 TV_CGRAPHOPT
, /* tv_id */
1025 0, /* properties_required */
1026 0, /* properties_provided */
1027 0, /* properties_destroyed */
1028 0, /* todo_flags_start */
1029 TODO_remove_functions
| TODO_dump_cgraph
1030 | TODO_ggc_collect
/* todo_flags_finish */
1034 /* Do not re-run on ltrans stage. */
1037 gate_whole_program_function_and_variable_visibility (void)
1039 return !flag_ltrans
;
1042 /* Bring functionss local at LTO time whith -fwhole-program. */
1045 whole_program_function_and_variable_visibility (void)
1047 struct cgraph_node
*node
;
1048 struct varpool_node
*vnode
;
1050 function_and_variable_visibility (flag_whole_program
);
1052 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1053 if ((node
->local
.externally_visible
&& !DECL_COMDAT (node
->decl
))
1054 && node
->local
.finalized
)
1055 cgraph_mark_needed_node (node
);
1056 for (vnode
= varpool_nodes_queue
; vnode
; vnode
= vnode
->next_needed
)
1057 if (vnode
->externally_visible
&& !DECL_COMDAT (vnode
->decl
))
1058 varpool_mark_needed_node (vnode
);
1061 fprintf (dump_file
, "\nNeeded variables:");
1062 for (vnode
= varpool_nodes_queue
; vnode
; vnode
= vnode
->next_needed
)
1064 fprintf (dump_file
, " %s", varpool_node_name (vnode
));
1065 fprintf (dump_file
, "\n\n");
1068 ipa_discover_readonly_nonaddressable_vars ();
1072 struct ipa_opt_pass_d pass_ipa_whole_program_visibility
=
1076 "whole-program", /* name */
1077 gate_whole_program_function_and_variable_visibility
,/* gate */
1078 whole_program_function_and_variable_visibility
,/* execute */
1081 0, /* static_pass_number */
1082 TV_CGRAPHOPT
, /* tv_id */
1083 0, /* properties_required */
1084 0, /* properties_provided */
1085 0, /* properties_destroyed */
1086 0, /* todo_flags_start */
1087 TODO_remove_functions
| TODO_dump_cgraph
1088 | TODO_ggc_collect
/* todo_flags_finish */
1090 NULL
, /* generate_summary */
1091 NULL
, /* write_summary */
1092 NULL
, /* read_summary */
1093 NULL
, /* write_optimization_summary */
1094 NULL
, /* read_optimization_summary */
1095 NULL
, /* stmt_fixup */
1097 NULL
, /* function_transform */
1098 NULL
, /* variable_transform */
1102 /* Simple ipa profile pass propagating frequencies across the callgraph. */
1107 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1108 struct cgraph_edge
*e
;
1110 bool something_changed
= false;
1113 order_pos
= ipa_reverse_postorder (order
);
1114 for (i
= order_pos
- 1; i
>= 0; i
--)
1116 if (order
[i
]->local
.local
&& cgraph_propagate_frequency (order
[i
]))
1118 for (e
= order
[i
]->callees
; e
; e
= e
->next_callee
)
1119 if (e
->callee
->local
.local
&& !e
->callee
->aux
)
1121 something_changed
= true;
1122 e
->callee
->aux
= (void *)1;
1125 order
[i
]->aux
= NULL
;
1128 while (something_changed
)
1130 something_changed
= false;
1131 for (i
= order_pos
- 1; i
>= 0; i
--)
1133 if (order
[i
]->aux
&& cgraph_propagate_frequency (order
[i
]))
1135 for (e
= order
[i
]->callees
; e
; e
= e
->next_callee
)
1136 if (e
->callee
->local
.local
&& !e
->callee
->aux
)
1138 something_changed
= true;
1139 e
->callee
->aux
= (void *)1;
1142 order
[i
]->aux
= NULL
;
1150 gate_ipa_profile (void)
1152 return flag_ipa_profile
;
1155 struct ipa_opt_pass_d pass_ipa_profile
=
1159 "profile_estimate", /* name */
1160 gate_ipa_profile
, /* gate */
1161 ipa_profile
, /* execute */
1164 0, /* static_pass_number */
1165 TV_IPA_PROFILE
, /* tv_id */
1166 0, /* properties_required */
1167 0, /* properties_provided */
1168 0, /* properties_destroyed */
1169 0, /* todo_flags_start */
1170 0 /* todo_flags_finish */
1172 NULL
, /* generate_summary */
1173 NULL
, /* write_summary */
1174 NULL
, /* read_summary */
1175 NULL
, /* write_optimization_summary */
1176 NULL
, /* read_optimization_summary */
1177 NULL
, /* stmt_fixup */
1179 NULL
, /* function_transform */
1180 NULL
/* variable_transform */
1183 /* Generate and emit a static constructor or destructor. WHICH must
1184 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
1185 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
1186 initialization priority for this constructor or destructor.
1188 FINAL specify whether the externally visible name for collect2 should
1192 cgraph_build_static_cdtor_1 (char which
, tree body
, int priority
, bool final
)
1194 static int counter
= 0;
1196 tree decl
, name
, resdecl
;
1198 /* The priority is encoded in the constructor or destructor name.
1199 collect2 will sort the names and arrange that they are called at
1202 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
1204 /* Proudce sane name but one not recognizable by collect2, just for the
1205 case we fail to inline the function. */
1206 sprintf (which_buf
, "sub_%c_%.5d_%d", which
, priority
, counter
++);
1207 name
= get_file_function_name (which_buf
);
1209 decl
= build_decl (input_location
, FUNCTION_DECL
, name
,
1210 build_function_type_list (void_type_node
, NULL_TREE
));
1211 current_function_decl
= decl
;
1213 resdecl
= build_decl (input_location
,
1214 RESULT_DECL
, NULL_TREE
, void_type_node
);
1215 DECL_ARTIFICIAL (resdecl
) = 1;
1216 DECL_RESULT (decl
) = resdecl
;
1217 DECL_CONTEXT (resdecl
) = decl
;
1219 allocate_struct_function (decl
, false);
1221 TREE_STATIC (decl
) = 1;
1222 TREE_USED (decl
) = 1;
1223 DECL_ARTIFICIAL (decl
) = 1;
1224 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
1225 DECL_SAVED_TREE (decl
) = body
;
1226 if (!targetm
.have_ctors_dtors
&& final
)
1228 TREE_PUBLIC (decl
) = 1;
1229 DECL_PRESERVE_P (decl
) = 1;
1231 DECL_UNINLINABLE (decl
) = 1;
1233 DECL_INITIAL (decl
) = make_node (BLOCK
);
1234 TREE_USED (DECL_INITIAL (decl
)) = 1;
1236 DECL_SOURCE_LOCATION (decl
) = input_location
;
1237 cfun
->function_end_locus
= input_location
;
1242 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
1243 decl_init_priority_insert (decl
, priority
);
1246 DECL_STATIC_DESTRUCTOR (decl
) = 1;
1247 decl_fini_priority_insert (decl
, priority
);
1253 gimplify_function_tree (decl
);
1255 cgraph_add_new_function (decl
, false);
1258 current_function_decl
= NULL
;
1261 /* Generate and emit a static constructor or destructor. WHICH must
1262 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
1263 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
1264 initialization priority for this constructor or destructor. */
1267 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
1269 cgraph_build_static_cdtor_1 (which
, body
, priority
, false);
1272 /* A vector of FUNCTION_DECLs declared as static constructors. */
1273 static VEC(tree
, heap
) *static_ctors
;
1274 /* A vector of FUNCTION_DECLs declared as static destructors. */
1275 static VEC(tree
, heap
) *static_dtors
;
1277 /* When target does not have ctors and dtors, we call all constructor
1278 and destructor by special initialization/destruction function
1279 recognized by collect2.
1281 When we are going to build this function, collect all constructors and
1282 destructors and turn them into normal functions. */
1285 record_cdtor_fn (struct cgraph_node
*node
)
1287 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
1288 VEC_safe_push (tree
, heap
, static_ctors
, node
->decl
);
1289 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
1290 VEC_safe_push (tree
, heap
, static_dtors
, node
->decl
);
1291 node
= cgraph_get_node (node
->decl
);
1292 DECL_DISREGARD_INLINE_LIMITS (node
->decl
) = 1;
1295 /* Define global constructors/destructor functions for the CDTORS, of
1296 which they are LEN. The CDTORS are sorted by initialization
1297 priority. If CTOR_P is true, these are constructors; otherwise,
1298 they are destructors. */
1301 build_cdtor (bool ctor_p
, VEC (tree
, heap
) *cdtors
)
1304 size_t len
= VEC_length (tree
, cdtors
);
1311 priority_type priority
;
1319 fn
= VEC_index (tree
, cdtors
, j
);
1320 p
= ctor_p
? DECL_INIT_PRIORITY (fn
) : DECL_FINI_PRIORITY (fn
);
1323 else if (p
!= priority
)
1329 /* When there is only one cdtor and target supports them, do nothing. */
1331 && targetm
.have_ctors_dtors
)
1336 /* Find the next batch of constructors/destructors with the same
1337 initialization priority. */
1341 fn
= VEC_index (tree
, cdtors
, i
);
1342 call
= build_call_expr (fn
, 0);
1344 DECL_STATIC_CONSTRUCTOR (fn
) = 0;
1346 DECL_STATIC_DESTRUCTOR (fn
) = 0;
1347 /* We do not want to optimize away pure/const calls here.
1348 When optimizing, these should be already removed, when not
1349 optimizing, we want user to be able to breakpoint in them. */
1350 TREE_SIDE_EFFECTS (call
) = 1;
1351 append_to_statement_list (call
, &body
);
1353 gcc_assert (body
!= NULL_TREE
);
1354 /* Generate a function to call all the function of like
1356 cgraph_build_static_cdtor_1 (ctor_p
? 'I' : 'D', body
, priority
, true);
1360 /* Comparison function for qsort. P1 and P2 are actually of type
1361 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
1362 used to determine the sort order. */
1365 compare_ctor (const void *p1
, const void *p2
)
1372 f1
= *(const tree
*)p1
;
1373 f2
= *(const tree
*)p2
;
1374 priority1
= DECL_INIT_PRIORITY (f1
);
1375 priority2
= DECL_INIT_PRIORITY (f2
);
1377 if (priority1
< priority2
)
1379 else if (priority1
> priority2
)
1382 /* Ensure a stable sort. Constructors are executed in backwarding
1383 order to make LTO initialize braries first. */
1384 return DECL_UID (f2
) - DECL_UID (f1
);
1387 /* Comparison function for qsort. P1 and P2 are actually of type
1388 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
1389 used to determine the sort order. */
1392 compare_dtor (const void *p1
, const void *p2
)
1399 f1
= *(const tree
*)p1
;
1400 f2
= *(const tree
*)p2
;
1401 priority1
= DECL_FINI_PRIORITY (f1
);
1402 priority2
= DECL_FINI_PRIORITY (f2
);
1404 if (priority1
< priority2
)
1406 else if (priority1
> priority2
)
1409 /* Ensure a stable sort. */
1410 return DECL_UID (f1
) - DECL_UID (f2
);
1413 /* Generate functions to call static constructors and destructors
1414 for targets that do not support .ctors/.dtors sections. These
1415 functions have magic names which are detected by collect2. */
1418 build_cdtor_fns (void)
1420 if (!VEC_empty (tree
, static_ctors
))
1422 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1423 VEC_qsort (tree
, static_ctors
, compare_ctor
);
1424 build_cdtor (/*ctor_p=*/true, static_ctors
);
1427 if (!VEC_empty (tree
, static_dtors
))
1429 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1430 VEC_qsort (tree
, static_dtors
, compare_dtor
);
1431 build_cdtor (/*ctor_p=*/false, static_dtors
);
1435 /* Look for constructors and destructors and produce function calling them.
1436 This is needed for targets not supporting ctors or dtors, but we perform the
1437 transformation also at linktime to merge possibly numberous
1438 constructors/destructors into single function to improve code locality and
1442 ipa_cdtor_merge (void)
1444 struct cgraph_node
*node
;
1445 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1447 && (DECL_STATIC_CONSTRUCTOR (node
->decl
)
1448 || DECL_STATIC_DESTRUCTOR (node
->decl
)))
1449 record_cdtor_fn (node
);
1451 VEC_free (tree
, heap
, static_ctors
);
1452 VEC_free (tree
, heap
, static_dtors
);
1456 /* Perform the pass when we have no ctors/dtors support
1457 or at LTO time to merge multiple constructors into single
1461 gate_ipa_cdtor_merge (void)
1463 return !targetm
.have_ctors_dtors
|| (optimize
&& in_lto_p
);
1466 struct ipa_opt_pass_d pass_ipa_cdtor_merge
=
1471 gate_ipa_cdtor_merge
, /* gate */
1472 ipa_cdtor_merge
, /* execute */
1475 0, /* static_pass_number */
1476 TV_CGRAPHOPT
, /* tv_id */
1477 0, /* properties_required */
1478 0, /* properties_provided */
1479 0, /* properties_destroyed */
1480 0, /* todo_flags_start */
1481 0 /* todo_flags_finish */
1483 NULL
, /* generate_summary */
1484 NULL
, /* write_summary */
1485 NULL
, /* read_summary */
1486 NULL
, /* write_optimization_summary */
1487 NULL
, /* read_optimization_summary */
1488 NULL
, /* stmt_fixup */
1490 NULL
, /* function_transform */
1491 NULL
/* variable_transform */