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 /* When doing LTO or whole program, we can bring COMDAT functoins static.
633 This improves code quality and we know we will duplicate them at most twice
634 (in the case that we are not using plugin and link with object file
635 implementing same COMDAT) */
636 if ((in_lto_p || whole_program)
637 && DECL_COMDAT (node->decl)
638 && cgraph_comdat_can_be_unshared_p (node))
641 /* When doing link time optimizations, hidden symbols become local. */
643 && (DECL_VISIBILITY (node->decl) == VISIBILITY_HIDDEN
644 || DECL_VISIBILITY (node->decl) == VISIBILITY_INTERNAL)
645 /* Be sure that node is defined in IR file, not in other object
646 file. In that case we don't set used_from_other_object_file. */
649 else if (!whole_program)
652 if (MAIN_NAME_P (DECL_NAME (node->decl)))
658 /* Return true when variable VNODE should be considered externally visible. */
661 varpool_externally_visible_p (struct varpool_node *vnode, bool aliased)
663 struct varpool_node *alias;
664 if (!DECL_COMDAT (vnode->decl) && !TREE_PUBLIC (vnode->decl))
667 /* Do not even try to be smart about aliased nodes. Until we properly
668 represent everything by same body alias, these are just evil. */
672 /* If linker counts on us, we must preserve the function. */
673 if (varpool_used_from_object_file_p (vnode))
676 /* FIXME: We get wrong symbols with asm aliases in callgraph and LTO.
677 This is because very little of code knows that assembler name needs to
678 mangled. Avoid touching declarations with user asm name set to mask
679 some of the problems. */
680 if (DECL_ASSEMBLER_NAME_SET_P (vnode->decl)
681 && IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (vnode->decl))[0]=='*')
684 if (DECL_PRESERVE_P (vnode->decl))
686 if (lookup_attribute ("externally_visible",
687 DECL_ATTRIBUTES (vnode->decl)))
689 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
690 && lookup_attribute ("dllexport",
691 DECL_ATTRIBUTES (vnode->decl)))
694 /* See if we have linker information about symbol not being used or
695 if we need to make guess based on the declaration.
697 Even if the linker clams the symbol is unused, never bring internal
698 symbols that are declared by user as used or externally visible.
699 This is needed for i.e. references from asm statements. */
700 if (varpool_used_from_object_file_p (vnode))
702 for (alias = vnode->extra_name; alias; alias = alias->next)
703 if (alias->resolution != LDPR_PREVAILING_DEF_IRONLY)
705 if (!alias && vnode->resolution == LDPR_PREVAILING_DEF_IRONLY)
708 /* As a special case, the COMDAT virutal tables can be unshared.
709 In LTO mode turn vtables into static variables. The variable is readonly,
710 so this does not enable more optimization, but referring static var
711 is faster for dynamic linking. Also this match logic hidding vtables
712 from LTO symbol tables. */
713 if ((in_lto_p || flag_whole_program)
714 && !vnode->force_output
715 && DECL_COMDAT (vnode->decl) && DECL_VIRTUAL_P (vnode->decl))
718 /* When doing link time optimizations, hidden symbols become local. */
720 && (DECL_VISIBILITY (vnode->decl) == VISIBILITY_HIDDEN
721 || DECL_VISIBILITY (vnode->decl) == VISIBILITY_INTERNAL)
722 /* Be sure that node is defined in IR file, not in other object
723 file. In that case we don't set used_from_other_object_file. */
726 else if (!flag_whole_program)
729 /* Do not attempt to privatize COMDATS by default.
730 This would break linking with C++ libraries sharing
733 FIXME: We can do so for readonly vars with no address taken and
734 possibly also for vtables since no direct pointer comparsion is done.
735 It might be interesting to do so to reduce linking overhead. */
736 if (DECL_COMDAT (vnode->decl) || DECL_WEAK (vnode->decl))
741 /* Dissolve the same_comdat_group list in which NODE resides. */
744 dissolve_same_comdat_group_list (struct cgraph_node *node)
746 struct cgraph_node *n = node, *next;
749 next = n->same_comdat_group;
750 n->same_comdat_group = NULL;
756 /* Mark visibility of all functions.
758 A local function is one whose calls can occur only in the current
759 compilation unit and all its calls are explicit, so we can change
760 its calling convention. We simply mark all static functions whose
761 address is not taken as local.
763 We also change the TREE_PUBLIC flag of all declarations that are public
764 in language point of view but we want to overwrite this default
765 via visibilities for the backend point of view. */
768 function_and_variable_visibility (bool whole_program)
770 struct cgraph_node *node;
771 struct varpool_node *vnode;
772 struct pointer_set_t *aliased_nodes = pointer_set_create ();
773 struct pointer_set_t *aliased_vnodes = pointer_set_create ();
777 /* Discover aliased nodes. */
778 FOR_EACH_VEC_ELT (alias_pair, alias_pairs, i, p)
781 fprintf (dump_file, "Alias %s->%s",
782 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (p->decl)),
783 IDENTIFIER_POINTER (p->target));
785 if ((node = cgraph_node_for_asm (p->target)) != NULL
786 && !DECL_EXTERNAL (node->decl))
790 /* Weakrefs alias symbols from other compilation unit. In the case
791 the destination of weakref became available because of LTO, we must
792 mark it as needed. */
794 && lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl))
796 cgraph_mark_needed_node (node);
797 gcc_assert (node->needed);
798 pointer_set_insert (aliased_nodes, node);
800 fprintf (dump_file, " node %s/%i",
801 cgraph_node_name (node), node->uid);
803 else if ((vnode = varpool_node_for_asm (p->target)) != NULL
804 && !DECL_EXTERNAL (vnode->decl))
806 /* Weakrefs alias symbols from other compilation unit. In the case
807 the destination of weakref became available because of LTO, we must
808 mark it as needed. */
810 && lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl))
812 varpool_mark_needed_node (vnode);
813 gcc_assert (vnode->needed);
814 pointer_set_insert (aliased_vnodes, vnode);
816 fprintf (dump_file, " varpool node %s",
817 varpool_node_name (vnode));
820 fprintf (dump_file, "\n");
823 for (node = cgraph_nodes; node; node = node->next)
825 int flags = flags_from_decl_or_type (node->decl);
827 /* Optimize away PURE and CONST constructors and destructors. */
829 && (flags & (ECF_CONST | ECF_PURE))
830 && !(flags & ECF_LOOPING_CONST_OR_PURE))
832 DECL_STATIC_CONSTRUCTOR (node->decl) = 0;
833 DECL_STATIC_DESTRUCTOR (node->decl) = 0;
836 /* Frontends and alias code marks nodes as needed before parsing is finished.
837 We may end up marking as node external nodes where this flag is meaningless
840 && (DECL_EXTERNAL (node->decl) || !node->analyzed))
843 /* C++ FE on lack of COMDAT support create local COMDAT functions
844 (that ought to be shared but can not due to object format
845 limitations). It is neccesary to keep the flag to make rest of C++ FE
846 happy. Clear the flag here to avoid confusion in middle-end. */
847 if (DECL_COMDAT (node->decl) && !TREE_PUBLIC (node->decl))
848 DECL_COMDAT (node->decl) = 0;
849 /* For external decls stop tracking same_comdat_group, it doesn't matter
850 what comdat group they are in when they won't be emitted in this TU,
851 and simplifies later passes. */
852 if (node->same_comdat_group && DECL_EXTERNAL (node->decl))
854 #ifdef ENABLE_CHECKING
855 struct cgraph_node *n;
857 for (n = node->same_comdat_group;
859 n = n->same_comdat_group)
860 /* If at least one of same comdat group functions is external,
861 all of them have to be, otherwise it is a front-end bug. */
862 gcc_assert (DECL_EXTERNAL (n->decl));
864 dissolve_same_comdat_group_list (node);
866 gcc_assert ((!DECL_WEAK (node->decl) && !DECL_COMDAT (node->decl))
867 || TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl));
868 if (cgraph_externally_visible_p (node, whole_program,
869 pointer_set_contains (aliased_nodes,
872 gcc_assert (!node->global.inlined_to);
873 node->local.externally_visible = true;
876 node->local.externally_visible = false;
877 if (!node->local.externally_visible && node->analyzed
878 && !DECL_EXTERNAL (node->decl))
880 gcc_assert (whole_program || in_lto_p || !TREE_PUBLIC (node->decl));
881 cgraph_make_decl_local (node->decl);
882 node->resolution = LDPR_PREVAILING_DEF_IRONLY;
883 if (node->same_comdat_group)
884 /* cgraph_externally_visible_p has already checked all other nodes
885 in the group and they will all be made local. We need to
886 dissolve the group at once so that the predicate does not
888 dissolve_same_comdat_group_list (node);
891 if (node->thunk.thunk_p
892 && TREE_PUBLIC (node->decl))
894 struct cgraph_node *decl_node = node;
896 decl_node = cgraph_function_node (decl_node->callees->callee, NULL);
898 /* Thunks have the same visibility as function they are attached to.
899 For some reason C++ frontend don't seem to care. I.e. in
900 g++.dg/torture/pr41257-2.C the thunk is not comdat while function
901 it is attached to is.
903 We also need to arrange the thunk into the same comdat group as
904 the function it reffers to. */
905 if (DECL_COMDAT (decl_node->decl))
907 DECL_COMDAT (node->decl) = 1;
908 DECL_COMDAT_GROUP (node->decl) = DECL_COMDAT_GROUP (decl_node->decl);
909 if (DECL_ONE_ONLY (decl_node->decl) && !node->same_comdat_group)
911 node->same_comdat_group = decl_node;
912 if (!decl_node->same_comdat_group)
913 decl_node->same_comdat_group = node;
916 struct cgraph_node *n;
917 for (n = decl_node->same_comdat_group;
918 n->same_comdat_group != decl_node;
919 n = n->same_comdat_group)
921 n->same_comdat_group = node;
925 if (DECL_EXTERNAL (decl_node->decl))
926 DECL_EXTERNAL (node->decl) = 1;
929 for (node = cgraph_nodes; node; node = node->next)
930 node->local.local = cgraph_local_node_p (node);
931 for (vnode = varpool_nodes; vnode; vnode = vnode->next)
933 /* weak flag makes no sense on local variables. */
934 gcc_assert (!DECL_WEAK (vnode->decl)
935 || TREE_PUBLIC (vnode->decl) || DECL_EXTERNAL (vnode->decl));
936 /* In several cases declarations can not be common:
938 - when declaration has initializer
940 - when it has specific section
941 - when it resides in non-generic address space.
942 - if declaration is local, it will get into .local common section
943 so common flag is not needed. Frontends still produce these in
944 certain cases, such as for:
946 static int a __attribute__ ((common))
948 Canonicalize things here and clear the redundant flag. */
949 if (DECL_COMMON (vnode->decl)
950 && (!(TREE_PUBLIC (vnode->decl) || DECL_EXTERNAL (vnode->decl))
951 || (DECL_INITIAL (vnode->decl)
952 && DECL_INITIAL (vnode->decl) != error_mark_node)
953 || DECL_WEAK (vnode->decl)
954 || DECL_SECTION_NAME (vnode->decl) != NULL
955 || ! (ADDR_SPACE_GENERIC_P
956 (TYPE_ADDR_SPACE (TREE_TYPE (vnode->decl))))))
957 DECL_COMMON (vnode->decl) = 0;
959 for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
961 if (!vnode->finalized)
964 && varpool_externally_visible_p
966 pointer_set_contains (aliased_vnodes, vnode)))
967 vnode->externally_visible = true;
969 vnode->externally_visible = false;
970 if (!vnode->externally_visible)
972 gcc_assert (in_lto_p || whole_program || !TREE_PUBLIC (vnode->decl));
973 cgraph_make_decl_local (vnode->decl);
974 vnode->resolution = LDPR_PREVAILING_DEF_IRONLY;
976 gcc_assert (TREE_STATIC (vnode->decl));
978 pointer_set_destroy (aliased_nodes);
979 pointer_set_destroy (aliased_vnodes);
983 fprintf (dump_file, "\nMarking local functions:");
984 for (node = cgraph_nodes; node; node = node->next)
985 if (node->local.local)
986 fprintf (dump_file, " %s", cgraph_node_name (node));
987 fprintf (dump_file, "\n\n");
988 fprintf (dump_file, "\nMarking externally visible functions:");
989 for (node = cgraph_nodes; node; node = node->next)
990 if (node->local.externally_visible)
991 fprintf (dump_file, " %s", cgraph_node_name (node));
992 fprintf (dump_file, "\n\n");
993 fprintf (dump_file, "\nMarking externally visible variables:");
994 for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
995 if (vnode->externally_visible)
996 fprintf (dump_file, " %s", varpool_node_name (vnode));
997 fprintf (dump_file, "\n\n");
999 cgraph_function_flags_ready = true;
1003 /* Local function pass handling visibilities. This happens before LTO streaming
1004 so in particular -fwhole-program should be ignored at this level. */
1007 local_function_and_variable_visibility (void)
1009 return function_and_variable_visibility (flag_whole_program && !flag_lto);
1012 struct simple_ipa_opt_pass pass_ipa_function_and_variable_visibility =
1016 "visibility", /* name */
1018 local_function_and_variable_visibility,/* execute */
1021 0, /* static_pass_number */
1022 TV_CGRAPHOPT, /* tv_id */
1023 0, /* properties_required */
1024 0, /* properties_provided */
1025 0, /* properties_destroyed */
1026 0, /* todo_flags_start */
1027 TODO_remove_functions | TODO_dump_cgraph
1028 | TODO_ggc_collect /* todo_flags_finish */
1032 /* Do not re-run on ltrans stage. */
1035 gate_whole_program_function_and_variable_visibility (void)
1037 return !flag_ltrans;
1040 /* Bring functionss local at LTO time whith -fwhole-program. */
1043 whole_program_function_and_variable_visibility (void)
1045 struct cgraph_node *node;
1046 struct varpool_node *vnode;
1048 function_and_variable_visibility (flag_whole_program);
1050 for (node = cgraph_nodes; node; node = node->next)
1051 if ((node->local.externally_visible && !DECL_COMDAT (node->decl))
1052 && node->local.finalized)
1053 cgraph_mark_needed_node (node);
1054 for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
1055 if (vnode->externally_visible && !DECL_COMDAT (vnode->decl))
1056 varpool_mark_needed_node (vnode);
1059 fprintf (dump_file, "\nNeeded variables:");
1060 for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
1062 fprintf (dump_file, " %s", varpool_node_name (vnode));
1063 fprintf (dump_file, "\n\n");
1066 ipa_discover_readonly_nonaddressable_vars ();
1070 struct ipa_opt_pass_d pass_ipa_whole_program_visibility =
1074 "whole-program", /* name */
1075 gate_whole_program_function_and_variable_visibility,/* gate */
1076 whole_program_function_and_variable_visibility,/* execute */
1079 0, /* static_pass_number */
1080 TV_CGRAPHOPT, /* tv_id */
1081 0, /* properties_required */
1082 0, /* properties_provided */
1083 0, /* properties_destroyed */
1084 0, /* todo_flags_start */
1085 TODO_remove_functions | TODO_dump_cgraph
1086 | TODO_ggc_collect /* todo_flags_finish */
1088 NULL, /* generate_summary */
1089 NULL, /* write_summary */
1090 NULL, /* read_summary */
1091 NULL, /* write_optimization_summary */
1092 NULL, /* read_optimization_summary */
1093 NULL, /* stmt_fixup */
1095 NULL, /* function_transform */
1096 NULL, /* variable_transform */
1100 /* Simple ipa profile pass propagating frequencies across the callgraph. */
1105 struct cgraph_node **order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
1106 struct cgraph_edge *e;
1108 bool something_changed = false;
1111 order_pos = ipa_reverse_postorder (order);
1112 for (i = order_pos - 1; i >= 0; i--)
1114 if (order[i]->local.local && cgraph_propagate_frequency (order[i]))
1116 for (e = order[i]->callees; e; e = e->next_callee)
1117 if (e->callee->local.local && !e->callee->aux)
1119 something_changed = true;
1120 e->callee->aux = (void *)1;
1123 order[i]->aux = NULL;
1126 while (something_changed)
1128 something_changed = false;
1129 for (i = order_pos - 1; i >= 0; i--)
1131 if (order[i]->aux && cgraph_propagate_frequency (order[i]))
1133 for (e = order[i]->callees; e; e = e->next_callee)
1134 if (e->callee->local.local && !e->callee->aux)
1136 something_changed = true;
1137 e->callee->aux = (void *)1;
1140 order[i]->aux = NULL;
1148 gate_ipa_profile (void)
1150 return flag_ipa_profile;
1153 struct ipa_opt_pass_d pass_ipa_profile =
1157 "profile_estimate", /* name */
1158 gate_ipa_profile, /* gate */
1159 ipa_profile, /* execute */
1162 0, /* static_pass_number */
1163 TV_IPA_PROFILE, /* tv_id */
1164 0, /* properties_required */
1165 0, /* properties_provided */
1166 0, /* properties_destroyed */
1167 0, /* todo_flags_start */
1168 0 /* todo_flags_finish */
1170 NULL, /* generate_summary */
1171 NULL, /* write_summary */
1172 NULL, /* read_summary */
1173 NULL, /* write_optimization_summary */
1174 NULL, /* read_optimization_summary */
1175 NULL, /* stmt_fixup */
1177 NULL, /* function_transform */
1178 NULL /* variable_transform */
1181 /* Generate and emit a static constructor or destructor. WHICH must
1182 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
1183 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
1184 initialization priority for this constructor or destructor.
1186 FINAL specify whether the externally visible name for collect2 should
1190 cgraph_build_static_cdtor_1 (char which, tree body, int priority, bool final)
1192 static int counter = 0;
1194 tree decl, name, resdecl;
1196 /* The priority is encoded in the constructor or destructor name.
1197 collect2 will sort the names and arrange that they are called at
1200 sprintf (which_buf, "%c_%.5d_%d", which, priority, counter++);
1202 /* Proudce sane name but one not recognizable by collect2, just for the
1203 case we fail to inline the function. */
1204 sprintf (which_buf, "sub_%c_%.5d_%d", which, priority, counter++);
1205 name = get_file_function_name (which_buf);
1207 decl = build_decl (input_location, FUNCTION_DECL, name,
1208 build_function_type_list (void_type_node, NULL_TREE));
1209 current_function_decl = decl;
1211 resdecl = build_decl (input_location,
1212 RESULT_DECL, NULL_TREE, void_type_node);
1213 DECL_ARTIFICIAL (resdecl) = 1;
1214 DECL_RESULT (decl) = resdecl;
1215 DECL_CONTEXT (resdecl) = decl;
1217 allocate_struct_function (decl, false);
1219 TREE_STATIC (decl) = 1;
1220 TREE_USED (decl) = 1;
1221 DECL_ARTIFICIAL (decl) = 1;
1222 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
1223 DECL_SAVED_TREE (decl) = body;
1224 if (!targetm.have_ctors_dtors && final)
1226 TREE_PUBLIC (decl) = 1;
1227 DECL_PRESERVE_P (decl) = 1;
1229 DECL_UNINLINABLE (decl) = 1;
1231 DECL_INITIAL (decl) = make_node (BLOCK);
1232 TREE_USED (DECL_INITIAL (decl)) = 1;
1234 DECL_SOURCE_LOCATION (decl) = input_location;
1235 cfun->function_end_locus = input_location;
1240 DECL_STATIC_CONSTRUCTOR (decl) = 1;
1241 decl_init_priority_insert (decl, priority);
1244 DECL_STATIC_DESTRUCTOR (decl) = 1;
1245 decl_fini_priority_insert (decl, priority);
1251 gimplify_function_tree (decl);
1253 cgraph_add_new_function (decl, false);
1256 current_function_decl = NULL;
1259 /* Generate and emit a static constructor or destructor. WHICH must
1260 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
1261 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
1262 initialization priority for this constructor or destructor. */
1265 cgraph_build_static_cdtor (char which, tree body, int priority)
1267 cgraph_build_static_cdtor_1 (which, body, priority, false);
1270 /* A vector of FUNCTION_DECLs declared as static constructors. */
1271 static VEC(tree, heap) *static_ctors;
1272 /* A vector of FUNCTION_DECLs declared as static destructors. */
1273 static VEC(tree, heap) *static_dtors;
1275 /* When target does not have ctors and dtors, we call all constructor
1276 and destructor by special initialization/destruction function
1277 recognized by collect2.
1279 When we are going to build this function, collect all constructors and
1280 destructors and turn them into normal functions. */
1283 record_cdtor_fn (struct cgraph_node *node)
1285 if (DECL_STATIC_CONSTRUCTOR (node->decl))
1286 VEC_safe_push (tree, heap, static_ctors, node->decl);
1287 if (DECL_STATIC_DESTRUCTOR (node->decl))
1288 VEC_safe_push (tree, heap, static_dtors, node->decl);
1289 node = cgraph_get_node (node->decl);
1290 DECL_DISREGARD_INLINE_LIMITS (node->decl) = 1;
1293 /* Define global constructors/destructor functions for the CDTORS, of
1294 which they are LEN. The CDTORS are sorted by initialization
1295 priority. If CTOR_P is true, these are constructors; otherwise,
1296 they are destructors. */
1299 build_cdtor (bool ctor_p, VEC (tree, heap) *cdtors)
1302 size_t len = VEC_length (tree, cdtors);
1309 priority_type priority;
1317 fn = VEC_index (tree, cdtors, j);
1318 p = ctor_p ? DECL_INIT_PRIORITY (fn) : DECL_FINI_PRIORITY (fn);
1321 else if (p != priority)
1327 /* When there is only one cdtor and target supports them, do nothing. */
1329 && targetm.have_ctors_dtors)
1334 /* Find the next batch of constructors/destructors with the same
1335 initialization priority. */
1339 fn = VEC_index (tree, cdtors, i);
1340 call = build_call_expr (fn, 0);
1342 DECL_STATIC_CONSTRUCTOR (fn) = 0;
1344 DECL_STATIC_DESTRUCTOR (fn) = 0;
1345 /* We do not want to optimize away pure/const calls here.
1346 When optimizing, these should be already removed, when not
1347 optimizing, we want user to be able to breakpoint in them. */
1348 TREE_SIDE_EFFECTS (call) = 1;
1349 append_to_statement_list (call, &body);
1351 gcc_assert (body != NULL_TREE);
1352 /* Generate a function to call all the function of like
1354 cgraph_build_static_cdtor_1 (ctor_p ? 'I' : 'D', body, priority, true);
1358 /* Comparison function for qsort. P1 and P2 are actually of type
1359 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
1360 used to determine the sort order. */
1363 compare_ctor (const void *p1, const void *p2)
1370 f1 = *(const tree *)p1;
1371 f2 = *(const tree *)p2;
1372 priority1 = DECL_INIT_PRIORITY (f1);
1373 priority2 = DECL_INIT_PRIORITY (f2);
1375 if (priority1 < priority2)
1377 else if (priority1 > priority2)
1380 /* Ensure a stable sort. Constructors are executed in backwarding
1381 order to make LTO initialize braries first. */
1382 return DECL_UID (f2) - DECL_UID (f1);
1385 /* Comparison function for qsort. P1 and P2 are actually of type
1386 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
1387 used to determine the sort order. */
1390 compare_dtor (const void *p1, const void *p2)
1397 f1 = *(const tree *)p1;
1398 f2 = *(const tree *)p2;
1399 priority1 = DECL_FINI_PRIORITY (f1);
1400 priority2 = DECL_FINI_PRIORITY (f2);
1402 if (priority1 < priority2)
1404 else if (priority1 > priority2)
1407 /* Ensure a stable sort. */
1408 return DECL_UID (f1) - DECL_UID (f2);
1411 /* Generate functions to call static constructors and destructors
1412 for targets that do not support .ctors/.dtors sections. These
1413 functions have magic names which are detected by collect2. */
1416 build_cdtor_fns (void)
1418 if (!VEC_empty (tree, static_ctors))
1420 gcc_assert (!targetm.have_ctors_dtors || in_lto_p);
1421 VEC_qsort (tree, static_ctors, compare_ctor);
1422 build_cdtor (/*ctor_p=*/true, static_ctors);
1425 if (!VEC_empty (tree, static_dtors))
1427 gcc_assert (!targetm.have_ctors_dtors || in_lto_p);
1428 VEC_qsort (tree, static_dtors, compare_dtor);
1429 build_cdtor (/*ctor_p=*/false, static_dtors);
1433 /* Look for constructors and destructors and produce function calling them.
1434 This is needed for targets not supporting ctors or dtors, but we perform the
1435 transformation also at linktime to merge possibly numberous
1436 constructors/destructors into single function to improve code locality and
1440 ipa_cdtor_merge (void)
1442 struct cgraph_node *node;
1443 for (node = cgraph_nodes; node; node = node->next)
1445 && (DECL_STATIC_CONSTRUCTOR (node->decl)
1446 || DECL_STATIC_DESTRUCTOR (node->decl)))
1447 record_cdtor_fn (node);
1449 VEC_free (tree, heap, static_ctors);
1450 VEC_free (tree, heap, static_dtors);
1454 /* Perform the pass when we have no ctors/dtors support
1455 or at LTO time to merge multiple constructors into single
1459 gate_ipa_cdtor_merge (void)
1461 return !targetm.have_ctors_dtors || (optimize && in_lto_p);
1464 struct ipa_opt_pass_d pass_ipa_cdtor_merge =
1469 gate_ipa_cdtor_merge, /* gate */
1470 ipa_cdtor_merge, /* execute */
1473 0, /* static_pass_number */
1474 TV_CGRAPHOPT, /* tv_id */
1475 0, /* properties_required */
1476 0, /* properties_provided */
1477 0, /* properties_destroyed */
1478 0, /* todo_flags_start */
1479 0 /* todo_flags_finish */
1481 NULL, /* generate_summary */
1482 NULL, /* write_summary */
1483 NULL, /* read_summary */
1484 NULL, /* write_optimization_summary */
1485 NULL, /* read_optimization_summary */
1486 NULL, /* stmt_fixup */
1488 NULL, /* function_transform */
1489 NULL /* variable_transform */