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_refering_iterate (&node
->ref_list
, i
, ref
); i
++)
546 if (ref
->use
== IPA_REF_ADDR
)
548 struct varpool_node
*node
;
549 if (ref
->refering_type
== IPA_REF_CGRAPH
)
551 node
= ipa_ref_refering_varpool_node (ref
);
552 if (!DECL_VIRTUAL_P (node
->decl
))
558 /* COMDAT functions must be shared only if they have address taken,
559 otherwise we can produce our own private implementation with
561 Return true when turning COMDAT functoin static can not lead to wrong
562 code when the resulting object links with a library defining same COMDAT.
564 Virtual functions do have their addresses taken from the vtables,
565 but in C++ there is no way to compare their addresses for equality. */
568 cgraph_comdat_can_be_unshared_p (struct cgraph_node
*node
)
570 if ((cgraph_address_taken_from_non_vtable_p (node
)
571 && !DECL_VIRTUAL_P (node
->decl
))
574 if (node
->same_comdat_group
)
576 struct cgraph_node
*next
;
578 /* If more than one function is in the same COMDAT group, it must
579 be shared even if just one function in the comdat group has
581 for (next
= node
->same_comdat_group
;
582 next
!= node
; next
= next
->same_comdat_group
)
583 if (cgraph_address_taken_from_non_vtable_p (next
)
584 && !DECL_VIRTUAL_P (next
->decl
))
590 /* Return true when function NODE should be considered externally visible. */
593 cgraph_externally_visible_p (struct cgraph_node
*node
,
594 bool whole_program
, bool aliased
)
596 if (!node
->local
.finalized
)
598 if (!DECL_COMDAT (node
->decl
)
599 && (!TREE_PUBLIC (node
->decl
) || DECL_EXTERNAL (node
->decl
)))
602 /* Do not even try to be smart about aliased nodes. Until we properly
603 represent everything by same body alias, these are just evil. */
607 /* Do not try to localize built-in functions yet. One of problems is that we
608 end up mangling their asm for WHOPR that makes it impossible to call them
609 using the implicit built-in declarations anymore. Similarly this enables
610 us to remove them as unreachable before actual calls may appear during
611 expansion or folding. */
612 if (DECL_BUILT_IN (node
->decl
))
615 /* If linker counts on us, we must preserve the function. */
616 if (cgraph_used_from_object_file_p (node
))
618 if (DECL_PRESERVE_P (node
->decl
))
620 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (node
->decl
)))
622 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
623 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (node
->decl
)))
625 if (node
->resolution
== LDPR_PREVAILING_DEF_IRONLY
)
627 /* When doing LTO or whole program, we can bring COMDAT functoins static.
628 This improves code quality and we know we will duplicate them at most twice
629 (in the case that we are not using plugin and link with object file
630 implementing same COMDAT) */
631 if ((in_lto_p
|| whole_program
)
632 && DECL_COMDAT (node
->decl
)
633 && cgraph_comdat_can_be_unshared_p (node
))
636 /* When doing link time optimizations, hidden symbols become local. */
638 && (DECL_VISIBILITY (node
->decl
) == VISIBILITY_HIDDEN
639 || DECL_VISIBILITY (node
->decl
) == VISIBILITY_INTERNAL
)
640 /* Be sure that node is defined in IR file, not in other object
641 file. In that case we don't set used_from_other_object_file. */
644 else if (!whole_program
)
647 if (MAIN_NAME_P (DECL_NAME (node
->decl
)))
653 /* Return true when variable VNODE should be considered externally visible. */
656 varpool_externally_visible_p (struct varpool_node
*vnode
, bool aliased
)
658 if (!DECL_COMDAT (vnode
->decl
) && !TREE_PUBLIC (vnode
->decl
))
661 /* Do not even try to be smart about aliased nodes. Until we properly
662 represent everything by same body alias, these are just evil. */
666 /* If linker counts on us, we must preserve the function. */
667 if (varpool_used_from_object_file_p (vnode
))
670 if (DECL_PRESERVE_P (vnode
->decl
))
672 if (lookup_attribute ("externally_visible",
673 DECL_ATTRIBUTES (vnode
->decl
)))
675 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
676 && lookup_attribute ("dllexport",
677 DECL_ATTRIBUTES (vnode
->decl
)))
680 /* See if we have linker information about symbol not being used or
681 if we need to make guess based on the declaration.
683 Even if the linker clams the symbol is unused, never bring internal
684 symbols that are declared by user as used or externally visible.
685 This is needed for i.e. references from asm statements. */
686 if (varpool_used_from_object_file_p (vnode
))
689 /* As a special case, the COMDAT virutal tables can be unshared.
690 In LTO mode turn vtables into static variables. The variable is readonly,
691 so this does not enable more optimization, but referring static var
692 is faster for dynamic linking. Also this match logic hidding vtables
693 from LTO symbol tables. */
694 if ((in_lto_p
|| flag_whole_program
)
695 && !vnode
->force_output
696 && DECL_COMDAT (vnode
->decl
) && DECL_VIRTUAL_P (vnode
->decl
))
699 /* When doing link time optimizations, hidden symbols become local. */
701 && (DECL_VISIBILITY (vnode
->decl
) == VISIBILITY_HIDDEN
702 || DECL_VISIBILITY (vnode
->decl
) == VISIBILITY_INTERNAL
)
703 /* Be sure that node is defined in IR file, not in other object
704 file. In that case we don't set used_from_other_object_file. */
707 else if (!flag_whole_program
)
710 /* Do not attempt to privatize COMDATS by default.
711 This would break linking with C++ libraries sharing
714 FIXME: We can do so for readonly vars with no address taken and
715 possibly also for vtables since no direct pointer comparsion is done.
716 It might be interesting to do so to reduce linking overhead. */
717 if (DECL_COMDAT (vnode
->decl
) || DECL_WEAK (vnode
->decl
))
722 /* Dissolve the same_comdat_group list in which NODE resides. */
725 dissolve_same_comdat_group_list (struct cgraph_node
*node
)
727 struct cgraph_node
*n
= node
, *next
;
730 next
= n
->same_comdat_group
;
731 n
->same_comdat_group
= NULL
;
737 /* Mark visibility of all functions.
739 A local function is one whose calls can occur only in the current
740 compilation unit and all its calls are explicit, so we can change
741 its calling convention. We simply mark all static functions whose
742 address is not taken as local.
744 We also change the TREE_PUBLIC flag of all declarations that are public
745 in language point of view but we want to overwrite this default
746 via visibilities for the backend point of view. */
749 function_and_variable_visibility (bool whole_program
)
751 struct cgraph_node
*node
;
752 struct varpool_node
*vnode
;
753 struct pointer_set_t
*aliased_nodes
= pointer_set_create ();
754 struct pointer_set_t
*aliased_vnodes
= pointer_set_create ();
758 /* Discover aliased nodes. */
759 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
762 fprintf (dump_file
, "Alias %s->%s",
763 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (p
->decl
)),
764 IDENTIFIER_POINTER (p
->target
));
766 if ((node
= cgraph_node_for_asm (p
->target
)) != NULL
767 && !DECL_EXTERNAL (node
->decl
))
771 cgraph_mark_needed_node (node
);
772 gcc_assert (node
->needed
);
773 pointer_set_insert (aliased_nodes
, node
);
775 fprintf (dump_file
, " node %s/%i",
776 cgraph_node_name (node
), node
->uid
);
778 else if ((vnode
= varpool_node_for_asm (p
->target
)) != NULL
779 && !DECL_EXTERNAL (vnode
->decl
))
781 varpool_mark_needed_node (vnode
);
782 gcc_assert (vnode
->needed
);
783 pointer_set_insert (aliased_vnodes
, vnode
);
785 fprintf (dump_file
, " varpool node %s",
786 varpool_node_name (vnode
));
789 fprintf (dump_file
, "\n");
792 for (node
= cgraph_nodes
; node
; node
= node
->next
)
794 int flags
= flags_from_decl_or_type (node
->decl
);
796 /* Optimize away PURE and CONST constructors and destructors. */
798 && (flags
& (ECF_CONST
| ECF_PURE
))
799 && !(flags
& ECF_LOOPING_CONST_OR_PURE
))
801 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
802 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
805 /* Frontends and alias code marks nodes as needed before parsing is finished.
806 We may end up marking as node external nodes where this flag is meaningless
809 && (DECL_EXTERNAL (node
->decl
) || !node
->analyzed
))
812 /* C++ FE on lack of COMDAT support create local COMDAT functions
813 (that ought to be shared but can not due to object format
814 limitations). It is neccesary to keep the flag to make rest of C++ FE
815 happy. Clear the flag here to avoid confusion in middle-end. */
816 if (DECL_COMDAT (node
->decl
) && !TREE_PUBLIC (node
->decl
))
817 DECL_COMDAT (node
->decl
) = 0;
818 /* For external decls stop tracking same_comdat_group, it doesn't matter
819 what comdat group they are in when they won't be emitted in this TU,
820 and simplifies later passes. */
821 if (node
->same_comdat_group
&& DECL_EXTERNAL (node
->decl
))
823 #ifdef ENABLE_CHECKING
824 struct cgraph_node
*n
;
826 for (n
= node
->same_comdat_group
;
828 n
= n
->same_comdat_group
)
829 /* If at least one of same comdat group functions is external,
830 all of them have to be, otherwise it is a front-end bug. */
831 gcc_assert (DECL_EXTERNAL (n
->decl
));
833 dissolve_same_comdat_group_list (node
);
835 gcc_assert ((!DECL_WEAK (node
->decl
) && !DECL_COMDAT (node
->decl
))
836 || TREE_PUBLIC (node
->decl
) || DECL_EXTERNAL (node
->decl
));
837 if (cgraph_externally_visible_p (node
, whole_program
,
838 pointer_set_contains (aliased_nodes
,
841 gcc_assert (!node
->global
.inlined_to
);
842 node
->local
.externally_visible
= true;
845 node
->local
.externally_visible
= false;
846 if (!node
->local
.externally_visible
&& node
->analyzed
847 && !DECL_EXTERNAL (node
->decl
))
849 gcc_assert (whole_program
|| in_lto_p
|| !TREE_PUBLIC (node
->decl
));
850 cgraph_make_decl_local (node
->decl
);
851 node
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
852 if (node
->same_comdat_group
)
853 /* cgraph_externally_visible_p has already checked all other nodes
854 in the group and they will all be made local. We need to
855 dissolve the group at once so that the predicate does not
857 dissolve_same_comdat_group_list (node
);
860 if (node
->thunk
.thunk_p
861 && TREE_PUBLIC (node
->decl
))
863 struct cgraph_node
*decl_node
= node
;
865 decl_node
= cgraph_function_node (decl_node
->callees
->callee
, NULL
);
867 /* Thunks have the same visibility as function they are attached to.
868 For some reason C++ frontend don't seem to care. I.e. in
869 g++.dg/torture/pr41257-2.C the thunk is not comdat while function
870 it is attached to is.
872 We also need to arrange the thunk into the same comdat group as
873 the function it reffers to. */
874 if (DECL_ONE_ONLY (decl_node
->decl
))
876 DECL_COMDAT (node
->decl
) = DECL_COMDAT (decl_node
->decl
);
877 DECL_COMDAT_GROUP (node
->decl
) = DECL_COMDAT_GROUP (decl_node
->decl
);
878 if (DECL_ONE_ONLY (decl_node
->decl
) && !node
->same_comdat_group
)
880 node
->same_comdat_group
= decl_node
;
881 if (!decl_node
->same_comdat_group
)
882 decl_node
->same_comdat_group
= node
;
885 struct cgraph_node
*n
;
886 for (n
= decl_node
->same_comdat_group
;
887 n
->same_comdat_group
!= decl_node
;
888 n
= n
->same_comdat_group
)
890 n
->same_comdat_group
= node
;
894 if (DECL_EXTERNAL (decl_node
->decl
))
895 DECL_EXTERNAL (node
->decl
) = 1;
898 for (node
= cgraph_nodes
; node
; node
= node
->next
)
899 node
->local
.local
= cgraph_local_node_p (node
);
900 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
902 /* weak flag makes no sense on local variables. */
903 gcc_assert (!DECL_WEAK (vnode
->decl
)
904 || TREE_PUBLIC (vnode
->decl
) || DECL_EXTERNAL (vnode
->decl
));
905 /* In several cases declarations can not be common:
907 - when declaration has initializer
909 - when it has specific section
910 - when it resides in non-generic address space.
911 - if declaration is local, it will get into .local common section
912 so common flag is not needed. Frontends still produce these in
913 certain cases, such as for:
915 static int a __attribute__ ((common))
917 Canonicalize things here and clear the redundant flag. */
918 if (DECL_COMMON (vnode
->decl
)
919 && (!(TREE_PUBLIC (vnode
->decl
) || DECL_EXTERNAL (vnode
->decl
))
920 || (DECL_INITIAL (vnode
->decl
)
921 && DECL_INITIAL (vnode
->decl
) != error_mark_node
)
922 || DECL_WEAK (vnode
->decl
)
923 || DECL_SECTION_NAME (vnode
->decl
) != NULL
924 || ! (ADDR_SPACE_GENERIC_P
925 (TYPE_ADDR_SPACE (TREE_TYPE (vnode
->decl
))))))
926 DECL_COMMON (vnode
->decl
) = 0;
928 for (vnode
= varpool_nodes_queue
; vnode
; vnode
= vnode
->next_needed
)
930 if (!vnode
->finalized
)
933 && varpool_externally_visible_p
935 pointer_set_contains (aliased_vnodes
, vnode
)))
936 vnode
->externally_visible
= true;
938 vnode
->externally_visible
= false;
939 if (!vnode
->externally_visible
)
941 gcc_assert (in_lto_p
|| whole_program
|| !TREE_PUBLIC (vnode
->decl
));
942 cgraph_make_decl_local (vnode
->decl
);
943 vnode
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
945 gcc_assert (TREE_STATIC (vnode
->decl
));
947 pointer_set_destroy (aliased_nodes
);
948 pointer_set_destroy (aliased_vnodes
);
952 fprintf (dump_file
, "\nMarking local functions:");
953 for (node
= cgraph_nodes
; node
; node
= node
->next
)
954 if (node
->local
.local
)
955 fprintf (dump_file
, " %s", cgraph_node_name (node
));
956 fprintf (dump_file
, "\n\n");
957 fprintf (dump_file
, "\nMarking externally visible functions:");
958 for (node
= cgraph_nodes
; node
; node
= node
->next
)
959 if (node
->local
.externally_visible
)
960 fprintf (dump_file
, " %s", cgraph_node_name (node
));
961 fprintf (dump_file
, "\n\n");
962 fprintf (dump_file
, "\nMarking externally visible variables:");
963 for (vnode
= varpool_nodes_queue
; vnode
; vnode
= vnode
->next_needed
)
964 if (vnode
->externally_visible
)
965 fprintf (dump_file
, " %s", varpool_node_name (vnode
));
966 fprintf (dump_file
, "\n\n");
968 cgraph_function_flags_ready
= true;
972 /* Local function pass handling visibilities. This happens before LTO streaming
973 so in particular -fwhole-program should be ignored at this level. */
976 local_function_and_variable_visibility (void)
978 return function_and_variable_visibility (flag_whole_program
&& !flag_lto
);
981 struct simple_ipa_opt_pass pass_ipa_function_and_variable_visibility
=
985 "visibility", /* name */
987 local_function_and_variable_visibility
,/* execute */
990 0, /* static_pass_number */
991 TV_CGRAPHOPT
, /* tv_id */
992 0, /* properties_required */
993 0, /* properties_provided */
994 0, /* properties_destroyed */
995 0, /* todo_flags_start */
996 TODO_remove_functions
| TODO_dump_cgraph
997 | TODO_ggc_collect
/* todo_flags_finish */
1001 /* Do not re-run on ltrans stage. */
1004 gate_whole_program_function_and_variable_visibility (void)
1006 return !flag_ltrans
;
1009 /* Bring functionss local at LTO time whith -fwhole-program. */
1012 whole_program_function_and_variable_visibility (void)
1014 struct cgraph_node
*node
;
1015 struct varpool_node
*vnode
;
1017 function_and_variable_visibility (flag_whole_program
);
1019 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1020 if ((node
->local
.externally_visible
&& !DECL_COMDAT (node
->decl
))
1021 && node
->local
.finalized
)
1022 cgraph_mark_needed_node (node
);
1023 for (vnode
= varpool_nodes_queue
; vnode
; vnode
= vnode
->next_needed
)
1024 if (vnode
->externally_visible
&& !DECL_COMDAT (vnode
->decl
))
1025 varpool_mark_needed_node (vnode
);
1028 fprintf (dump_file
, "\nNeeded variables:");
1029 for (vnode
= varpool_nodes_queue
; vnode
; vnode
= vnode
->next_needed
)
1031 fprintf (dump_file
, " %s", varpool_node_name (vnode
));
1032 fprintf (dump_file
, "\n\n");
1035 ipa_discover_readonly_nonaddressable_vars ();
1039 struct ipa_opt_pass_d pass_ipa_whole_program_visibility
=
1043 "whole-program", /* name */
1044 gate_whole_program_function_and_variable_visibility
,/* gate */
1045 whole_program_function_and_variable_visibility
,/* execute */
1048 0, /* static_pass_number */
1049 TV_CGRAPHOPT
, /* tv_id */
1050 0, /* properties_required */
1051 0, /* properties_provided */
1052 0, /* properties_destroyed */
1053 0, /* todo_flags_start */
1054 TODO_remove_functions
| TODO_dump_cgraph
1055 | TODO_ggc_collect
/* todo_flags_finish */
1057 NULL
, /* generate_summary */
1058 NULL
, /* write_summary */
1059 NULL
, /* read_summary */
1060 NULL
, /* write_optimization_summary */
1061 NULL
, /* read_optimization_summary */
1062 NULL
, /* stmt_fixup */
1064 NULL
, /* function_transform */
1065 NULL
, /* variable_transform */
1069 /* Simple ipa profile pass propagating frequencies across the callgraph. */
1074 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1075 struct cgraph_edge
*e
;
1077 bool something_changed
= false;
1080 order_pos
= ipa_reverse_postorder (order
);
1081 for (i
= order_pos
- 1; i
>= 0; i
--)
1083 if (order
[i
]->local
.local
&& cgraph_propagate_frequency (order
[i
]))
1085 for (e
= order
[i
]->callees
; e
; e
= e
->next_callee
)
1086 if (e
->callee
->local
.local
&& !e
->callee
->aux
)
1088 something_changed
= true;
1089 e
->callee
->aux
= (void *)1;
1092 order
[i
]->aux
= NULL
;
1095 while (something_changed
)
1097 something_changed
= false;
1098 for (i
= order_pos
- 1; i
>= 0; i
--)
1100 if (order
[i
]->aux
&& cgraph_propagate_frequency (order
[i
]))
1102 for (e
= order
[i
]->callees
; e
; e
= e
->next_callee
)
1103 if (e
->callee
->local
.local
&& !e
->callee
->aux
)
1105 something_changed
= true;
1106 e
->callee
->aux
= (void *)1;
1109 order
[i
]->aux
= NULL
;
1117 gate_ipa_profile (void)
1119 return flag_ipa_profile
;
1122 struct ipa_opt_pass_d pass_ipa_profile
=
1126 "profile_estimate", /* name */
1127 gate_ipa_profile
, /* gate */
1128 ipa_profile
, /* execute */
1131 0, /* static_pass_number */
1132 TV_IPA_PROFILE
, /* tv_id */
1133 0, /* properties_required */
1134 0, /* properties_provided */
1135 0, /* properties_destroyed */
1136 0, /* todo_flags_start */
1137 0 /* todo_flags_finish */
1139 NULL
, /* generate_summary */
1140 NULL
, /* write_summary */
1141 NULL
, /* read_summary */
1142 NULL
, /* write_optimization_summary */
1143 NULL
, /* read_optimization_summary */
1144 NULL
, /* stmt_fixup */
1146 NULL
, /* function_transform */
1147 NULL
/* variable_transform */
1150 /* Generate and emit a static constructor or destructor. WHICH must
1151 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
1152 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
1153 initialization priority for this constructor or destructor.
1155 FINAL specify whether the externally visible name for collect2 should
1159 cgraph_build_static_cdtor_1 (char which
, tree body
, int priority
, bool final
)
1161 static int counter
= 0;
1163 tree decl
, name
, resdecl
;
1165 /* The priority is encoded in the constructor or destructor name.
1166 collect2 will sort the names and arrange that they are called at
1169 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
1171 /* Proudce sane name but one not recognizable by collect2, just for the
1172 case we fail to inline the function. */
1173 sprintf (which_buf
, "sub_%c_%.5d_%d", which
, priority
, counter
++);
1174 name
= get_file_function_name (which_buf
);
1176 decl
= build_decl (input_location
, FUNCTION_DECL
, name
,
1177 build_function_type_list (void_type_node
, NULL_TREE
));
1178 current_function_decl
= decl
;
1180 resdecl
= build_decl (input_location
,
1181 RESULT_DECL
, NULL_TREE
, void_type_node
);
1182 DECL_ARTIFICIAL (resdecl
) = 1;
1183 DECL_RESULT (decl
) = resdecl
;
1184 DECL_CONTEXT (resdecl
) = decl
;
1186 allocate_struct_function (decl
, false);
1188 TREE_STATIC (decl
) = 1;
1189 TREE_USED (decl
) = 1;
1190 DECL_ARTIFICIAL (decl
) = 1;
1191 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
1192 DECL_SAVED_TREE (decl
) = body
;
1193 if (!targetm
.have_ctors_dtors
&& final
)
1195 TREE_PUBLIC (decl
) = 1;
1196 DECL_PRESERVE_P (decl
) = 1;
1198 DECL_UNINLINABLE (decl
) = 1;
1200 DECL_INITIAL (decl
) = make_node (BLOCK
);
1201 TREE_USED (DECL_INITIAL (decl
)) = 1;
1203 DECL_SOURCE_LOCATION (decl
) = input_location
;
1204 cfun
->function_end_locus
= input_location
;
1209 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
1210 decl_init_priority_insert (decl
, priority
);
1213 DECL_STATIC_DESTRUCTOR (decl
) = 1;
1214 decl_fini_priority_insert (decl
, priority
);
1220 gimplify_function_tree (decl
);
1222 cgraph_add_new_function (decl
, false);
1225 current_function_decl
= NULL
;
1228 /* Generate and emit a static constructor or destructor. WHICH must
1229 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
1230 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
1231 initialization priority for this constructor or destructor. */
1234 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
1236 cgraph_build_static_cdtor_1 (which
, body
, priority
, false);
1239 /* A vector of FUNCTION_DECLs declared as static constructors. */
1240 static VEC(tree
, heap
) *static_ctors
;
1241 /* A vector of FUNCTION_DECLs declared as static destructors. */
1242 static VEC(tree
, heap
) *static_dtors
;
1244 /* When target does not have ctors and dtors, we call all constructor
1245 and destructor by special initialization/destruction function
1246 recognized by collect2.
1248 When we are going to build this function, collect all constructors and
1249 destructors and turn them into normal functions. */
1252 record_cdtor_fn (struct cgraph_node
*node
)
1254 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
1255 VEC_safe_push (tree
, heap
, static_ctors
, node
->decl
);
1256 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
1257 VEC_safe_push (tree
, heap
, static_dtors
, node
->decl
);
1258 node
= cgraph_get_node (node
->decl
);
1259 DECL_DISREGARD_INLINE_LIMITS (node
->decl
) = 1;
1262 /* Define global constructors/destructor functions for the CDTORS, of
1263 which they are LEN. The CDTORS are sorted by initialization
1264 priority. If CTOR_P is true, these are constructors; otherwise,
1265 they are destructors. */
1268 build_cdtor (bool ctor_p
, VEC (tree
, heap
) *cdtors
)
1271 size_t len
= VEC_length (tree
, cdtors
);
1278 priority_type priority
;
1286 fn
= VEC_index (tree
, cdtors
, j
);
1287 p
= ctor_p
? DECL_INIT_PRIORITY (fn
) : DECL_FINI_PRIORITY (fn
);
1290 else if (p
!= priority
)
1296 /* When there is only one cdtor and target supports them, do nothing. */
1298 && targetm
.have_ctors_dtors
)
1303 /* Find the next batch of constructors/destructors with the same
1304 initialization priority. */
1308 fn
= VEC_index (tree
, cdtors
, i
);
1309 call
= build_call_expr (fn
, 0);
1311 DECL_STATIC_CONSTRUCTOR (fn
) = 0;
1313 DECL_STATIC_DESTRUCTOR (fn
) = 0;
1314 /* We do not want to optimize away pure/const calls here.
1315 When optimizing, these should be already removed, when not
1316 optimizing, we want user to be able to breakpoint in them. */
1317 TREE_SIDE_EFFECTS (call
) = 1;
1318 append_to_statement_list (call
, &body
);
1320 gcc_assert (body
!= NULL_TREE
);
1321 /* Generate a function to call all the function of like
1323 cgraph_build_static_cdtor_1 (ctor_p
? 'I' : 'D', body
, priority
, true);
1327 /* Comparison function for qsort. P1 and P2 are actually of type
1328 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
1329 used to determine the sort order. */
1332 compare_ctor (const void *p1
, const void *p2
)
1339 f1
= *(const tree
*)p1
;
1340 f2
= *(const tree
*)p2
;
1341 priority1
= DECL_INIT_PRIORITY (f1
);
1342 priority2
= DECL_INIT_PRIORITY (f2
);
1344 if (priority1
< priority2
)
1346 else if (priority1
> priority2
)
1349 /* Ensure a stable sort. Constructors are executed in backwarding
1350 order to make LTO initialize braries first. */
1351 return DECL_UID (f2
) - DECL_UID (f1
);
1354 /* Comparison function for qsort. P1 and P2 are actually of type
1355 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
1356 used to determine the sort order. */
1359 compare_dtor (const void *p1
, const void *p2
)
1366 f1
= *(const tree
*)p1
;
1367 f2
= *(const tree
*)p2
;
1368 priority1
= DECL_FINI_PRIORITY (f1
);
1369 priority2
= DECL_FINI_PRIORITY (f2
);
1371 if (priority1
< priority2
)
1373 else if (priority1
> priority2
)
1376 /* Ensure a stable sort. */
1377 return DECL_UID (f1
) - DECL_UID (f2
);
1380 /* Generate functions to call static constructors and destructors
1381 for targets that do not support .ctors/.dtors sections. These
1382 functions have magic names which are detected by collect2. */
1385 build_cdtor_fns (void)
1387 if (!VEC_empty (tree
, static_ctors
))
1389 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1390 VEC_qsort (tree
, static_ctors
, compare_ctor
);
1391 build_cdtor (/*ctor_p=*/true, static_ctors
);
1394 if (!VEC_empty (tree
, static_dtors
))
1396 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1397 VEC_qsort (tree
, static_dtors
, compare_dtor
);
1398 build_cdtor (/*ctor_p=*/false, static_dtors
);
1402 /* Look for constructors and destructors and produce function calling them.
1403 This is needed for targets not supporting ctors or dtors, but we perform the
1404 transformation also at linktime to merge possibly numberous
1405 constructors/destructors into single function to improve code locality and
1409 ipa_cdtor_merge (void)
1411 struct cgraph_node
*node
;
1412 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1414 && (DECL_STATIC_CONSTRUCTOR (node
->decl
)
1415 || DECL_STATIC_DESTRUCTOR (node
->decl
)))
1416 record_cdtor_fn (node
);
1418 VEC_free (tree
, heap
, static_ctors
);
1419 VEC_free (tree
, heap
, static_dtors
);
1423 /* Perform the pass when we have no ctors/dtors support
1424 or at LTO time to merge multiple constructors into single
1428 gate_ipa_cdtor_merge (void)
1430 return !targetm
.have_ctors_dtors
|| (optimize
&& in_lto_p
);
1433 struct ipa_opt_pass_d pass_ipa_cdtor_merge
=
1438 gate_ipa_cdtor_merge
, /* gate */
1439 ipa_cdtor_merge
, /* execute */
1442 0, /* static_pass_number */
1443 TV_CGRAPHOPT
, /* tv_id */
1444 0, /* properties_required */
1445 0, /* properties_provided */
1446 0, /* properties_destroyed */
1447 0, /* todo_flags_start */
1448 0 /* todo_flags_finish */
1450 NULL
, /* generate_summary */
1451 NULL
, /* write_summary */
1452 NULL
, /* read_summary */
1453 NULL
, /* write_optimization_summary */
1454 NULL
, /* read_optimization_summary */
1455 NULL
, /* stmt_fixup */
1457 NULL
, /* function_transform */
1458 NULL
/* variable_transform */