1 /* Basic IPA optimizations and utilities.
2 Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010
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"
35 /* Fill array order with all nodes with output flag set in the reverse
39 cgraph_postorder (struct cgraph_node
**order
)
41 struct cgraph_node
*node
, *node2
;
44 struct cgraph_edge
*edge
, last
;
47 struct cgraph_node
**stack
=
48 XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
50 /* We have to deal with cycles nicely, so use a depth first traversal
51 output algorithm. Ignore the fact that some functions won't need
52 to be output and put them into order as well, so we get dependencies
53 right through inline functions. */
54 for (node
= cgraph_nodes
; node
; node
= node
->next
)
56 for (pass
= 0; pass
< 2; pass
++)
57 for (node
= cgraph_nodes
; node
; node
= node
->next
)
60 || (!node
->address_taken
61 && !node
->global
.inlined_to
62 && !cgraph_only_called_directly_p (node
))))
68 node
->aux
= node
->callers
;
71 while (node2
->aux
!= &last
)
73 edge
= (struct cgraph_edge
*) node2
->aux
;
74 if (edge
->next_caller
)
75 node2
->aux
= edge
->next_caller
;
78 /* Break possible cycles involving always-inline
79 functions by ignoring edges from always-inline
80 functions to non-always-inline functions. */
81 if (edge
->caller
->local
.disregard_inline_limits
82 && !edge
->callee
->local
.disregard_inline_limits
)
84 if (!edge
->caller
->aux
)
86 if (!edge
->caller
->callers
)
87 edge
->caller
->aux
= &last
;
89 edge
->caller
->aux
= edge
->caller
->callers
;
90 stack
[stack_size
++] = node2
;
95 if (node2
->aux
== &last
)
97 order
[order_pos
++] = node2
;
99 node2
= stack
[--stack_size
];
106 for (node
= cgraph_nodes
; node
; node
= node
->next
)
111 /* Look for all functions inlined to NODE and update their inlined_to pointers
115 update_inlined_to_pointer (struct cgraph_node
*node
, struct cgraph_node
*inlined_to
)
117 struct cgraph_edge
*e
;
118 for (e
= node
->callees
; e
; e
= e
->next_callee
)
119 if (e
->callee
->global
.inlined_to
)
121 e
->callee
->global
.inlined_to
= inlined_to
;
122 update_inlined_to_pointer (e
->callee
, inlined_to
);
126 /* Add cgraph NODE to queue starting at FIRST.
128 The queue is linked via AUX pointers and terminated by pointer to 1.
129 We enqueue nodes at two occasions: when we find them reachable or when we find
130 their bodies needed for further clonning. In the second case we mark them
131 by pointer to 2 after processing so they are re-queue when they become
135 enqueue_cgraph_node (struct cgraph_node
*node
, struct cgraph_node
**first
)
137 /* Node is still in queue; do nothing. */
138 if (node
->aux
&& node
->aux
!= (void *) 2)
140 /* Node was already processed as unreachable, re-enqueue
141 only if it became reachable now. */
142 if (node
->aux
== (void *)2 && !node
->reachable
)
148 /* Add varpool NODE to queue starting at FIRST. */
151 enqueue_varpool_node (struct varpool_node
*node
, struct varpool_node
**first
)
157 /* Process references. */
160 process_references (struct ipa_ref_list
*list
,
161 struct cgraph_node
**first
,
162 struct varpool_node
**first_varpool
,
163 bool before_inlining_p
)
167 for (i
= 0; ipa_ref_list_reference_iterate (list
, i
, ref
); i
++)
169 if (ref
->refered_type
== IPA_REF_CGRAPH
)
171 struct cgraph_node
*node
= ipa_ref_node (ref
);
174 && (!DECL_EXTERNAL (node
->decl
)
175 || before_inlining_p
))
176 node
->reachable
= true;
177 enqueue_cgraph_node (node
, first
);
181 struct varpool_node
*node
= ipa_ref_varpool_node (ref
);
184 varpool_mark_needed_node (node
);
185 enqueue_varpool_node (node
, first_varpool
);
191 /* Return true when function can be marked local. */
194 cgraph_local_node_p (struct cgraph_node
*node
)
196 return (cgraph_only_called_directly_p (node
)
198 && !DECL_EXTERNAL (node
->decl
)
199 && !node
->local
.externally_visible
200 && !node
->reachable_from_other_partition
201 && !node
->in_other_partition
);
204 /* Perform reachability analysis and reclaim all unreachable nodes.
205 If BEFORE_INLINING_P is true this function is called before inlining
206 decisions has been made. If BEFORE_INLINING_P is false this function also
207 removes unneeded bodies of extern inline functions. */
210 cgraph_remove_unreachable_nodes (bool before_inlining_p
, FILE *file
)
212 struct cgraph_node
*first
= (struct cgraph_node
*) (void *) 1;
213 struct varpool_node
*first_varpool
= (struct varpool_node
*) (void *) 1;
214 struct cgraph_node
*node
, *next
;
215 struct varpool_node
*vnode
, *vnext
;
216 bool changed
= false;
218 #ifdef ENABLE_CHECKING
222 fprintf (file
, "\nReclaiming functions:");
223 #ifdef ENABLE_CHECKING
224 for (node
= cgraph_nodes
; node
; node
= node
->next
)
225 gcc_assert (!node
->aux
);
226 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
227 gcc_assert (!vnode
->aux
);
229 varpool_reset_queue ();
230 /* Mark functions whose bodies are obviously needed.
231 This is mostly when they can be referenced externally. Inline clones
232 are special since their declarations are shared with master clone and thus
233 cgraph_can_remove_if_no_direct_calls_and_refs_p should not be called on them. */
234 for (node
= cgraph_nodes
; node
; node
= node
->next
)
235 if (node
->analyzed
&& !node
->global
.inlined_to
236 && (!cgraph_can_remove_if_no_direct_calls_and_refs_p (node
)
237 /* Keep around virtual functions for possible devirtualization. */
238 || (before_inlining_p
239 && DECL_VIRTUAL_P (node
->decl
)
240 && (DECL_COMDAT (node
->decl
) || DECL_EXTERNAL (node
->decl
)))
241 /* Also external functions with address taken are better to stay
242 for indirect inlining. */
243 || (before_inlining_p
244 && DECL_EXTERNAL (node
->decl
)
245 && node
->address_taken
)))
247 gcc_assert (!node
->global
.inlined_to
);
248 enqueue_cgraph_node (node
, &first
);
249 node
->reachable
= true;
253 gcc_assert (!node
->aux
);
254 node
->reachable
= false;
257 /* Mark variables that are obviously needed. */
258 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
260 vnode
->next_needed
= NULL
;
261 vnode
->prev_needed
= NULL
;
263 && !varpool_can_remove_if_no_refs (vnode
))
265 vnode
->needed
= false;
266 varpool_mark_needed_node (vnode
);
267 enqueue_varpool_node (vnode
, &first_varpool
);
270 vnode
->needed
= false;
273 /* Perform reachability analysis. As a special case do not consider
274 extern inline functions not inlined as live because we won't output
277 We maintain two worklist, one for cgraph nodes other for varpools and
278 are finished once both are empty. */
280 while (first
!= (struct cgraph_node
*) (void *) 1
281 || first_varpool
!= (struct varpool_node
*) (void *) 1)
283 if (first
!= (struct cgraph_node
*) (void *) 1)
285 struct cgraph_edge
*e
;
287 first
= (struct cgraph_node
*) first
->aux
;
288 if (!node
->reachable
)
289 node
->aux
= (void *)2;
291 /* If we found this node reachable, first mark on the callees
292 reachable too, unless they are direct calls to extern inline functions
293 we decided to not inline. */
296 for (e
= node
->callees
; e
; e
= e
->next_callee
)
298 if (!e
->callee
->reachable
300 && (!e
->inline_failed
301 || !DECL_EXTERNAL (e
->callee
->decl
)
302 || before_inlining_p
))
303 e
->callee
->reachable
= true;
304 enqueue_cgraph_node (e
->callee
, &first
);
306 process_references (&node
->ref_list
, &first
, &first_varpool
, before_inlining_p
);
309 /* If any function in a comdat group is reachable, force
310 all other functions in the same comdat group to be
312 if (node
->same_comdat_group
314 && !node
->global
.inlined_to
)
316 for (next
= node
->same_comdat_group
;
318 next
= next
->same_comdat_group
)
319 if (!next
->reachable
)
321 next
->reachable
= true;
322 enqueue_cgraph_node (next
, &first
);
326 /* We can freely remove inline clones even if they are cloned, however if
327 function is clone of real clone, we must keep it around in order to
328 make materialize_clones produce function body with the changes
330 while (node
->clone_of
&& !node
->clone_of
->aux
331 && !gimple_has_body_p (node
->decl
))
333 bool noninline
= node
->clone_of
->decl
!= node
->decl
;
334 node
= node
->clone_of
;
335 if (noninline
&& !node
->reachable
&& !node
->aux
)
337 enqueue_cgraph_node (node
, &first
);
342 if (first_varpool
!= (struct varpool_node
*) (void *) 1)
344 vnode
= first_varpool
;
345 first_varpool
= (struct varpool_node
*)first_varpool
->aux
;
347 process_references (&vnode
->ref_list
, &first
, &first_varpool
, before_inlining_p
);
348 /* If any function in a comdat group is reachable, force
349 all other functions in the same comdat group to be
351 if (vnode
->same_comdat_group
)
353 struct varpool_node
*next
;
354 for (next
= vnode
->same_comdat_group
;
356 next
= next
->same_comdat_group
)
359 varpool_mark_needed_node (next
);
360 enqueue_varpool_node (next
, &first_varpool
);
366 /* Remove unreachable nodes.
368 Completely unreachable functions can be fully removed from the callgraph.
369 Extern inline functions that we decided to not inline need to become unanalyzed nodes of
370 callgraph (so we still have edges to them). We remove function body then.
372 Also we need to care functions that are unreachable but we need to keep them around
373 for later clonning. In this case we also turn them to unanalyzed nodes, but
374 keep the body around. */
375 for (node
= cgraph_nodes
; node
; node
= next
)
378 if (node
->aux
&& !node
->reachable
)
380 cgraph_node_remove_callees (node
);
381 ipa_remove_all_references (&node
->ref_list
);
382 node
->analyzed
= false;
383 node
->local
.inlinable
= false;
387 struct cgraph_edge
*e
;
392 node
->global
.inlined_to
= NULL
;
394 fprintf (file
, " %s", cgraph_node_name (node
));
395 /* See if there is reachable caller. */
396 for (e
= node
->callers
; e
&& !found
; e
= e
->next_caller
)
397 if (e
->caller
->reachable
)
399 for (i
= 0; (ipa_ref_list_refering_iterate (&node
->ref_list
, i
, ref
)
401 if (ref
->refering_type
== IPA_REF_CGRAPH
402 && ipa_ref_refering_node (ref
)->reachable
)
404 else if (ref
->refering_type
== IPA_REF_VARPOOL
405 && ipa_ref_refering_varpool_node (ref
)->needed
)
408 /* If so, we need to keep node in the callgraph. */
413 struct cgraph_node
*clone
;
415 /* If there are still clones, we must keep body around.
416 Otherwise we can just remove the body but keep the clone. */
417 for (clone
= node
->clones
; clone
;
418 clone
= clone
->next_sibling_clone
)
423 cgraph_release_function_body (node
);
424 node
->local
.inlinable
= false;
425 if (node
->prev_sibling_clone
)
426 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
427 else if (node
->clone_of
)
428 node
->clone_of
->clones
= node
->next_sibling_clone
;
429 if (node
->next_sibling_clone
)
430 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
432 node
->former_clone_of
= node
->clone_of
->decl
;
433 node
->clone_of
= NULL
;
434 node
->next_sibling_clone
= NULL
;
435 node
->prev_sibling_clone
= NULL
;
438 gcc_assert (!clone
->in_other_partition
);
439 node
->analyzed
= false;
441 cgraph_node_remove_callees (node
);
442 ipa_remove_all_references (&node
->ref_list
);
447 cgraph_remove_node (node
);
452 for (node
= cgraph_nodes
; node
; node
= node
->next
)
454 /* Inline clones might be kept around so their materializing allows further
455 cloning. If the function the clone is inlined into is removed, we need
456 to turn it into normal cone. */
457 if (node
->global
.inlined_to
460 gcc_assert (node
->clones
);
461 node
->global
.inlined_to
= NULL
;
462 update_inlined_to_pointer (node
, node
);
468 fprintf (file
, "\n");
470 /* We must release unused extern inlines or sanity checking will fail. Rest of transformations
471 are undesirable at -O0 since we do not want to remove anything. */
476 fprintf (file
, "Reclaiming variables:");
477 for (vnode
= varpool_nodes
; vnode
; vnode
= vnext
)
483 fprintf (file
, " %s", varpool_node_name (vnode
));
484 varpool_remove_node (vnode
);
489 /* Now update address_taken flags and try to promote functions to be local. */
492 fprintf (file
, "\nClearing address taken flags:");
493 for (node
= cgraph_nodes
; node
; node
= node
->next
)
494 if (node
->address_taken
495 && !node
->reachable_from_other_partition
)
500 for (i
= 0; ipa_ref_list_refering_iterate (&node
->ref_list
, i
, ref
)
503 gcc_assert (ref
->use
== IPA_REF_ADDR
);
509 fprintf (file
, " %s", cgraph_node_name (node
));
510 node
->address_taken
= false;
512 if (cgraph_local_node_p (node
))
514 node
->local
.local
= true;
516 fprintf (file
, " (local)");
521 #ifdef ENABLE_CHECKING
525 /* Reclaim alias pairs for functions that have disappeared from the
527 remove_unreachable_alias_pairs ();
532 /* Discover variables that have no longer address taken or that are read only
533 and update their flags.
535 FIXME: This can not be done in between gimplify and omp_expand since
536 readonly flag plays role on what is shared and what is not. Currently we do
537 this transformation as part of whole program visibility and re-do at
538 ipa-reference pass (to take into account clonning), but it would
539 make sense to do it before early optimizations. */
542 ipa_discover_readonly_nonaddressable_vars (void)
544 struct varpool_node
*vnode
;
546 fprintf (dump_file
, "Clearing variable flags:");
547 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
548 if (vnode
->finalized
&& varpool_all_refs_explicit_p (vnode
)
549 && (TREE_ADDRESSABLE (vnode
->decl
) || !TREE_READONLY (vnode
->decl
)))
551 bool written
= false;
552 bool address_taken
= false;
555 for (i
= 0; ipa_ref_list_refering_iterate (&vnode
->ref_list
, i
, ref
)
556 && (!written
|| !address_taken
); i
++)
560 address_taken
= true;
568 if (TREE_ADDRESSABLE (vnode
->decl
) && !address_taken
)
571 fprintf (dump_file
, " %s (addressable)", varpool_node_name (vnode
));
572 TREE_ADDRESSABLE (vnode
->decl
) = 0;
574 if (!TREE_READONLY (vnode
->decl
) && !address_taken
&& !written
575 /* Making variable in explicit section readonly can cause section
577 See e.g. gcc.c-torture/compile/pr23237.c */
578 && DECL_SECTION_NAME (vnode
->decl
) == NULL
)
581 fprintf (dump_file
, " %s (read-only)", varpool_node_name (vnode
));
582 TREE_READONLY (vnode
->decl
) = 1;
586 fprintf (dump_file
, "\n");
589 /* Return true when there is a reference to node and it is not vtable. */
591 cgraph_address_taken_from_non_vtable_p (struct cgraph_node
*node
)
595 for (i
= 0; ipa_ref_list_reference_iterate (&node
->ref_list
, i
, ref
); i
++)
597 struct varpool_node
*node
;
598 if (ref
->refered_type
== IPA_REF_CGRAPH
)
600 node
= ipa_ref_varpool_node (ref
);
601 if (!DECL_VIRTUAL_P (node
->decl
))
607 /* COMDAT functions must be shared only if they have address taken,
608 otherwise we can produce our own private implementation with
610 Return true when turning COMDAT functoin static can not lead to wrong
611 code when the resulting object links with a library defining same COMDAT.
613 Virtual functions do have their addresses taken from the vtables,
614 but in C++ there is no way to compare their addresses for equality. */
617 cgraph_comdat_can_be_unshared_p (struct cgraph_node
*node
)
619 if ((cgraph_address_taken_from_non_vtable_p (node
)
620 && !DECL_VIRTUAL_P (node
->decl
))
623 if (node
->same_comdat_group
)
625 struct cgraph_node
*next
;
627 /* If more than one function is in the same COMDAT group, it must
628 be shared even if just one function in the comdat group has
630 for (next
= node
->same_comdat_group
;
631 next
!= node
; next
= next
->same_comdat_group
)
632 if (cgraph_address_taken_from_non_vtable_p (node
)
633 && !DECL_VIRTUAL_P (next
->decl
))
639 /* Return true when function NODE should be considered externally visible. */
642 cgraph_externally_visible_p (struct cgraph_node
*node
, bool whole_program
, bool aliased
)
644 struct cgraph_node
*alias
;
645 if (!node
->local
.finalized
)
647 if (!DECL_COMDAT (node
->decl
)
648 && (!TREE_PUBLIC (node
->decl
) || DECL_EXTERNAL (node
->decl
)))
651 /* Do not even try to be smart about aliased nodes. Until we properly
652 represent everything by same body alias, these are just evil. */
656 /* Do not try to localize built-in functions yet. One of problems is that we
657 end up mangling their asm for WHOPR that makes it impossible to call them
658 using the implicit built-in declarations anymore. Similarly this enables
659 us to remove them as unreachable before actual calls may appear during
660 expansion or folding. */
661 if (DECL_BUILT_IN (node
->decl
))
664 /* FIXME: We get wrong symbols with asm aliases in callgraph and LTO.
665 This is because very little of code knows that assembler name needs to
666 mangled. Avoid touching declarations with user asm name set to mask
667 some of the problems. */
668 if (DECL_ASSEMBLER_NAME_SET_P (node
->decl
)
669 && IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node
->decl
))[0]=='*')
672 /* If linker counts on us, we must preserve the function. */
673 if (cgraph_used_from_object_file_p (node
))
675 if (DECL_PRESERVE_P (node
->decl
))
677 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (node
->decl
)))
679 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
680 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (node
->decl
)))
682 /* When doing LTO or whole program, we can bring COMDAT functoins static.
683 This improves code quality and we know we will duplicate them at most twice
684 (in the case that we are not using plugin and link with object file
685 implementing same COMDAT) */
686 if ((in_lto_p
|| whole_program
)
687 && DECL_COMDAT (node
->decl
)
688 && cgraph_comdat_can_be_unshared_p (node
))
691 /* See if we have linker information about symbol not being used or
692 if we need to make guess based on the declaration.
694 Even if the linker clams the symbol is unused, never bring internal
695 symbols that are declared by user as used or externally visible.
696 This is needed for i.e. references from asm statements. */
697 for (alias
= node
->same_body
; alias
; alias
= alias
->next
)
698 if (alias
->resolution
!= LDPR_PREVAILING_DEF_IRONLY
)
700 if (!alias
&& node
->resolution
== LDPR_PREVAILING_DEF_IRONLY
)
703 /* When doing link time optimizations, hidden symbols become local. */
705 && (DECL_VISIBILITY (node
->decl
) == VISIBILITY_HIDDEN
706 || DECL_VISIBILITY (node
->decl
) == VISIBILITY_INTERNAL
)
707 /* Be sure that node is defined in IR file, not in other object
708 file. In that case we don't set used_from_other_object_file. */
711 else if (!whole_program
)
714 if (MAIN_NAME_P (DECL_NAME (node
->decl
)))
720 /* Return true when variable VNODE should be considered externally visible. */
723 varpool_externally_visible_p (struct varpool_node
*vnode
, bool aliased
)
725 struct varpool_node
*alias
;
726 if (!DECL_COMDAT (vnode
->decl
) && !TREE_PUBLIC (vnode
->decl
))
729 /* Do not even try to be smart about aliased nodes. Until we properly
730 represent everything by same body alias, these are just evil. */
734 /* If linker counts on us, we must preserve the function. */
735 if (varpool_used_from_object_file_p (vnode
))
738 /* FIXME: We get wrong symbols with asm aliases in callgraph and LTO.
739 This is because very little of code knows that assembler name needs to
740 mangled. Avoid touching declarations with user asm name set to mask
741 some of the problems. */
742 if (DECL_ASSEMBLER_NAME_SET_P (vnode
->decl
)
743 && IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (vnode
->decl
))[0]=='*')
746 if (DECL_PRESERVE_P (vnode
->decl
))
748 if (lookup_attribute ("externally_visible",
749 DECL_ATTRIBUTES (vnode
->decl
)))
751 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
752 && lookup_attribute ("dllexport",
753 DECL_ATTRIBUTES (vnode
->decl
)))
756 /* See if we have linker information about symbol not being used or
757 if we need to make guess based on the declaration.
759 Even if the linker clams the symbol is unused, never bring internal
760 symbols that are declared by user as used or externally visible.
761 This is needed for i.e. references from asm statements. */
762 if (varpool_used_from_object_file_p (vnode
))
764 for (alias
= vnode
->extra_name
; alias
; alias
= alias
->next
)
765 if (alias
->resolution
!= LDPR_PREVAILING_DEF_IRONLY
)
767 if (!alias
&& vnode
->resolution
== LDPR_PREVAILING_DEF_IRONLY
)
770 /* As a special case, the COMDAT virutal tables can be unshared.
771 In LTO mode turn vtables into static variables. The variable is readonly,
772 so this does not enable more optimization, but referring static var
773 is faster for dynamic linking. Also this match logic hidding vtables
774 from LTO symbol tables. */
775 if ((in_lto_p
|| flag_whole_program
)
776 && !vnode
->force_output
777 && DECL_COMDAT (vnode
->decl
) && DECL_VIRTUAL_P (vnode
->decl
))
780 /* When doing link time optimizations, hidden symbols become local. */
782 && (DECL_VISIBILITY (vnode
->decl
) == VISIBILITY_HIDDEN
783 || DECL_VISIBILITY (vnode
->decl
) == VISIBILITY_INTERNAL
)
784 /* Be sure that node is defined in IR file, not in other object
785 file. In that case we don't set used_from_other_object_file. */
788 else if (!flag_whole_program
)
791 /* Do not attempt to privatize COMDATS by default.
792 This would break linking with C++ libraries sharing
795 FIXME: We can do so for readonly vars with no address taken and
796 possibly also for vtables since no direct pointer comparsion is done.
797 It might be interesting to do so to reduce linking overhead. */
798 if (DECL_COMDAT (vnode
->decl
) || DECL_WEAK (vnode
->decl
))
803 /* Dissolve the same_comdat_group list in which NODE resides. */
806 dissolve_same_comdat_group_list (struct cgraph_node
*node
)
808 struct cgraph_node
*n
= node
, *next
;
811 next
= n
->same_comdat_group
;
812 n
->same_comdat_group
= NULL
;
818 /* Mark visibility of all functions.
820 A local function is one whose calls can occur only in the current
821 compilation unit and all its calls are explicit, so we can change
822 its calling convention. We simply mark all static functions whose
823 address is not taken as local.
825 We also change the TREE_PUBLIC flag of all declarations that are public
826 in language point of view but we want to overwrite this default
827 via visibilities for the backend point of view. */
830 function_and_variable_visibility (bool whole_program
)
832 struct cgraph_node
*node
;
833 struct varpool_node
*vnode
;
834 struct pointer_set_t
*aliased_nodes
= pointer_set_create ();
835 struct pointer_set_t
*aliased_vnodes
= pointer_set_create ();
839 /* Discover aliased nodes. */
840 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
843 fprintf (dump_file
, "Alias %s->%s",
844 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (p
->decl
)),
845 IDENTIFIER_POINTER (p
->target
));
847 if ((node
= cgraph_node_for_asm (p
->target
)) != NULL
)
849 gcc_assert (node
->needed
);
850 pointer_set_insert (aliased_nodes
, node
);
852 fprintf (dump_file
, " node %s/%i",
853 cgraph_node_name (node
), node
->uid
);
855 else if ((vnode
= varpool_node_for_asm (p
->target
)) != NULL
)
857 gcc_assert (vnode
->needed
);
858 pointer_set_insert (aliased_vnodes
, vnode
);
860 fprintf (dump_file
, " varpool node %s",
861 varpool_node_name (vnode
));
864 fprintf (dump_file
, "\n");
867 for (node
= cgraph_nodes
; node
; node
= node
->next
)
869 int flags
= flags_from_decl_or_type (node
->decl
);
871 && (flags
& (ECF_CONST
| ECF_PURE
))
872 && !(flags
& ECF_LOOPING_CONST_OR_PURE
))
874 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
875 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
878 /* C++ FE on lack of COMDAT support create local COMDAT functions
879 (that ought to be shared but can not due to object format
880 limitations). It is neccesary to keep the flag to make rest of C++ FE
881 happy. Clear the flag here to avoid confusion in middle-end. */
882 if (DECL_COMDAT (node
->decl
) && !TREE_PUBLIC (node
->decl
))
883 DECL_COMDAT (node
->decl
) = 0;
884 /* For external decls stop tracking same_comdat_group, it doesn't matter
885 what comdat group they are in when they won't be emitted in this TU,
886 and simplifies later passes. */
887 if (node
->same_comdat_group
&& DECL_EXTERNAL (node
->decl
))
889 #ifdef ENABLE_CHECKING
890 struct cgraph_node
*n
;
892 for (n
= node
->same_comdat_group
;
894 n
= n
->same_comdat_group
)
895 /* If at least one of same comdat group functions is external,
896 all of them have to be, otherwise it is a front-end bug. */
897 gcc_assert (DECL_EXTERNAL (n
->decl
));
899 dissolve_same_comdat_group_list (node
);
901 gcc_assert ((!DECL_WEAK (node
->decl
) && !DECL_COMDAT (node
->decl
))
902 || TREE_PUBLIC (node
->decl
) || DECL_EXTERNAL (node
->decl
));
903 if (cgraph_externally_visible_p (node
, whole_program
,
904 pointer_set_contains (aliased_nodes
,
907 gcc_assert (!node
->global
.inlined_to
);
908 node
->local
.externally_visible
= true;
911 node
->local
.externally_visible
= false;
912 if (!node
->local
.externally_visible
&& node
->analyzed
913 && !DECL_EXTERNAL (node
->decl
))
915 struct cgraph_node
*alias
;
916 gcc_assert (whole_program
|| in_lto_p
|| !TREE_PUBLIC (node
->decl
));
917 cgraph_make_decl_local (node
->decl
);
918 node
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
919 for (alias
= node
->same_body
; alias
; alias
= alias
->next
)
920 cgraph_make_decl_local (alias
->decl
);
921 if (node
->same_comdat_group
)
922 /* cgraph_externally_visible_p has already checked all other nodes
923 in the group and they will all be made local. We need to
924 dissolve the group at once so that the predicate does not
926 dissolve_same_comdat_group_list (node
);
928 node
->local
.local
= cgraph_local_node_p (node
);
930 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
932 /* weak flag makes no sense on local variables. */
933 gcc_assert (!DECL_WEAK (vnode
->decl
)
934 || TREE_PUBLIC (vnode
->decl
) || DECL_EXTERNAL (vnode
->decl
));
935 /* In several cases declarations can not be common:
937 - when declaration has initializer
939 - when it has specific section
940 - when it resides in non-generic address space.
941 - if declaration is local, it will get into .local common section
942 so common flag is not needed. Frontends still produce these in
943 certain cases, such as for:
945 static int a __attribute__ ((common))
947 Canonicalize things here and clear the redundant flag. */
948 if (DECL_COMMON (vnode
->decl
)
949 && (!(TREE_PUBLIC (vnode
->decl
) || DECL_EXTERNAL (vnode
->decl
))
950 || (DECL_INITIAL (vnode
->decl
)
951 && DECL_INITIAL (vnode
->decl
) != error_mark_node
)
952 || DECL_WEAK (vnode
->decl
)
953 || DECL_SECTION_NAME (vnode
->decl
) != NULL
954 || ! (ADDR_SPACE_GENERIC_P
955 (TYPE_ADDR_SPACE (TREE_TYPE (vnode
->decl
))))))
956 DECL_COMMON (vnode
->decl
) = 0;
958 for (vnode
= varpool_nodes_queue
; vnode
; vnode
= vnode
->next_needed
)
960 if (!vnode
->finalized
)
963 && varpool_externally_visible_p
965 pointer_set_contains (aliased_vnodes
, vnode
)))
966 vnode
->externally_visible
= true;
968 vnode
->externally_visible
= false;
969 if (!vnode
->externally_visible
)
971 gcc_assert (in_lto_p
|| whole_program
|| !TREE_PUBLIC (vnode
->decl
));
972 cgraph_make_decl_local (vnode
->decl
);
973 vnode
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
975 gcc_assert (TREE_STATIC (vnode
->decl
));
977 pointer_set_destroy (aliased_nodes
);
978 pointer_set_destroy (aliased_vnodes
);
982 fprintf (dump_file
, "\nMarking local functions:");
983 for (node
= cgraph_nodes
; node
; node
= node
->next
)
984 if (node
->local
.local
)
985 fprintf (dump_file
, " %s", cgraph_node_name (node
));
986 fprintf (dump_file
, "\n\n");
987 fprintf (dump_file
, "\nMarking externally visible functions:");
988 for (node
= cgraph_nodes
; node
; node
= node
->next
)
989 if (node
->local
.externally_visible
)
990 fprintf (dump_file
, " %s", cgraph_node_name (node
));
991 fprintf (dump_file
, "\n\n");
992 fprintf (dump_file
, "\nMarking externally visible variables:");
993 for (vnode
= varpool_nodes_queue
; vnode
; vnode
= vnode
->next_needed
)
994 if (vnode
->externally_visible
)
995 fprintf (dump_file
, " %s", varpool_node_name (vnode
));
996 fprintf (dump_file
, "\n\n");
998 cgraph_function_flags_ready
= true;
1002 /* Local function pass handling visibilities. This happens before LTO streaming
1003 so in particular -fwhole-program should be ignored at this level. */
1006 local_function_and_variable_visibility (void)
1008 return function_and_variable_visibility (flag_whole_program
&& !flag_lto
);
1011 struct simple_ipa_opt_pass pass_ipa_function_and_variable_visibility
=
1015 "visibility", /* name */
1017 local_function_and_variable_visibility
,/* execute */
1020 0, /* static_pass_number */
1021 TV_CGRAPHOPT
, /* tv_id */
1022 0, /* properties_required */
1023 0, /* properties_provided */
1024 0, /* properties_destroyed */
1025 0, /* todo_flags_start */
1026 TODO_remove_functions
| TODO_dump_cgraph
1027 | TODO_ggc_collect
/* todo_flags_finish */
1031 /* Do not re-run on ltrans stage. */
1034 gate_whole_program_function_and_variable_visibility (void)
1036 return !flag_ltrans
;
1039 /* Bring functionss local at LTO time whith -fwhole-program. */
1042 whole_program_function_and_variable_visibility (void)
1044 struct cgraph_node
*node
;
1045 struct varpool_node
*vnode
;
1047 function_and_variable_visibility (flag_whole_program
);
1049 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1050 if ((node
->local
.externally_visible
&& !DECL_COMDAT (node
->decl
))
1051 && node
->local
.finalized
)
1052 cgraph_mark_needed_node (node
);
1053 for (vnode
= varpool_nodes_queue
; vnode
; vnode
= vnode
->next_needed
)
1054 if (vnode
->externally_visible
&& !DECL_COMDAT (vnode
->decl
))
1055 varpool_mark_needed_node (vnode
);
1058 fprintf (dump_file
, "\nNeeded variables:");
1059 for (vnode
= varpool_nodes_queue
; vnode
; vnode
= vnode
->next_needed
)
1061 fprintf (dump_file
, " %s", varpool_node_name (vnode
));
1062 fprintf (dump_file
, "\n\n");
1065 ipa_discover_readonly_nonaddressable_vars ();
1069 struct ipa_opt_pass_d pass_ipa_whole_program_visibility
=
1073 "whole-program", /* name */
1074 gate_whole_program_function_and_variable_visibility
,/* gate */
1075 whole_program_function_and_variable_visibility
,/* execute */
1078 0, /* static_pass_number */
1079 TV_CGRAPHOPT
, /* tv_id */
1080 0, /* properties_required */
1081 0, /* properties_provided */
1082 0, /* properties_destroyed */
1083 0, /* todo_flags_start */
1084 TODO_remove_functions
| TODO_dump_cgraph
1085 | TODO_ggc_collect
/* todo_flags_finish */
1087 NULL
, /* generate_summary */
1088 NULL
, /* write_summary */
1089 NULL
, /* read_summary */
1090 NULL
, /* write_optimization_summary */
1091 NULL
, /* read_optimization_summary */
1092 NULL
, /* stmt_fixup */
1094 NULL
, /* function_transform */
1095 NULL
, /* variable_transform */
1098 /* Hash a cgraph node set element. */
1101 hash_cgraph_node_set_element (const void *p
)
1103 const_cgraph_node_set_element element
= (const_cgraph_node_set_element
) p
;
1104 return htab_hash_pointer (element
->node
);
1107 /* Compare two cgraph node set elements. */
1110 eq_cgraph_node_set_element (const void *p1
, const void *p2
)
1112 const_cgraph_node_set_element e1
= (const_cgraph_node_set_element
) p1
;
1113 const_cgraph_node_set_element e2
= (const_cgraph_node_set_element
) p2
;
1115 return e1
->node
== e2
->node
;
1118 /* Create a new cgraph node set. */
1121 cgraph_node_set_new (void)
1123 cgraph_node_set new_node_set
;
1125 new_node_set
= ggc_alloc_cgraph_node_set_def ();
1126 new_node_set
->hashtab
= htab_create_ggc (10,
1127 hash_cgraph_node_set_element
,
1128 eq_cgraph_node_set_element
,
1130 new_node_set
->nodes
= NULL
;
1131 return new_node_set
;
1134 /* Add cgraph_node NODE to cgraph_node_set SET. */
1137 cgraph_node_set_add (cgraph_node_set set
, struct cgraph_node
*node
)
1140 cgraph_node_set_element element
;
1141 struct cgraph_node_set_element_def dummy
;
1144 slot
= htab_find_slot (set
->hashtab
, &dummy
, INSERT
);
1146 if (*slot
!= HTAB_EMPTY_ENTRY
)
1148 element
= (cgraph_node_set_element
) *slot
;
1149 gcc_assert (node
== element
->node
1150 && (VEC_index (cgraph_node_ptr
, set
->nodes
, element
->index
)
1155 /* Insert node into hash table. */
1156 element
= ggc_alloc_cgraph_node_set_element_def ();
1157 element
->node
= node
;
1158 element
->index
= VEC_length (cgraph_node_ptr
, set
->nodes
);
1161 /* Insert into node vector. */
1162 VEC_safe_push (cgraph_node_ptr
, gc
, set
->nodes
, node
);
1165 /* Remove cgraph_node NODE from cgraph_node_set SET. */
1168 cgraph_node_set_remove (cgraph_node_set set
, struct cgraph_node
*node
)
1170 void **slot
, **last_slot
;
1171 cgraph_node_set_element element
, last_element
;
1172 struct cgraph_node
*last_node
;
1173 struct cgraph_node_set_element_def dummy
;
1176 slot
= htab_find_slot (set
->hashtab
, &dummy
, NO_INSERT
);
1180 element
= (cgraph_node_set_element
) *slot
;
1181 gcc_assert (VEC_index (cgraph_node_ptr
, set
->nodes
, element
->index
)
1184 /* Remove from vector. We do this by swapping node with the last element
1186 last_node
= VEC_pop (cgraph_node_ptr
, set
->nodes
);
1187 if (last_node
!= node
)
1189 dummy
.node
= last_node
;
1190 last_slot
= htab_find_slot (set
->hashtab
, &dummy
, NO_INSERT
);
1191 last_element
= (cgraph_node_set_element
) *last_slot
;
1192 gcc_assert (last_element
);
1194 /* Move the last element to the original spot of NODE. */
1195 last_element
->index
= element
->index
;
1196 VEC_replace (cgraph_node_ptr
, set
->nodes
, last_element
->index
,
1200 /* Remove element from hash table. */
1201 htab_clear_slot (set
->hashtab
, slot
);
1205 /* Find NODE in SET and return an iterator to it if found. A null iterator
1206 is returned if NODE is not in SET. */
1208 cgraph_node_set_iterator
1209 cgraph_node_set_find (cgraph_node_set set
, struct cgraph_node
*node
)
1212 struct cgraph_node_set_element_def dummy
;
1213 cgraph_node_set_element element
;
1214 cgraph_node_set_iterator csi
;
1217 slot
= htab_find_slot (set
->hashtab
, &dummy
, NO_INSERT
);
1219 csi
.index
= (unsigned) ~0;
1222 element
= (cgraph_node_set_element
) *slot
;
1223 gcc_assert (VEC_index (cgraph_node_ptr
, set
->nodes
, element
->index
)
1225 csi
.index
= element
->index
;
1232 /* Dump content of SET to file F. */
1235 dump_cgraph_node_set (FILE *f
, cgraph_node_set set
)
1237 cgraph_node_set_iterator iter
;
1239 for (iter
= csi_start (set
); !csi_end_p (iter
); csi_next (&iter
))
1241 struct cgraph_node
*node
= csi_node (iter
);
1242 fprintf (f
, " %s/%i", cgraph_node_name (node
), node
->uid
);
1247 /* Dump content of SET to stderr. */
1250 debug_cgraph_node_set (cgraph_node_set set
)
1252 dump_cgraph_node_set (stderr
, set
);
1255 /* Hash a varpool node set element. */
1258 hash_varpool_node_set_element (const void *p
)
1260 const_varpool_node_set_element element
= (const_varpool_node_set_element
) p
;
1261 return htab_hash_pointer (element
->node
);
1264 /* Compare two varpool node set elements. */
1267 eq_varpool_node_set_element (const void *p1
, const void *p2
)
1269 const_varpool_node_set_element e1
= (const_varpool_node_set_element
) p1
;
1270 const_varpool_node_set_element e2
= (const_varpool_node_set_element
) p2
;
1272 return e1
->node
== e2
->node
;
1275 /* Create a new varpool node set. */
1278 varpool_node_set_new (void)
1280 varpool_node_set new_node_set
;
1282 new_node_set
= ggc_alloc_varpool_node_set_def ();
1283 new_node_set
->hashtab
= htab_create_ggc (10,
1284 hash_varpool_node_set_element
,
1285 eq_varpool_node_set_element
,
1287 new_node_set
->nodes
= NULL
;
1288 return new_node_set
;
1291 /* Add varpool_node NODE to varpool_node_set SET. */
1294 varpool_node_set_add (varpool_node_set set
, struct varpool_node
*node
)
1297 varpool_node_set_element element
;
1298 struct varpool_node_set_element_def dummy
;
1301 slot
= htab_find_slot (set
->hashtab
, &dummy
, INSERT
);
1303 if (*slot
!= HTAB_EMPTY_ENTRY
)
1305 element
= (varpool_node_set_element
) *slot
;
1306 gcc_assert (node
== element
->node
1307 && (VEC_index (varpool_node_ptr
, set
->nodes
, element
->index
)
1312 /* Insert node into hash table. */
1313 element
= ggc_alloc_varpool_node_set_element_def ();
1314 element
->node
= node
;
1315 element
->index
= VEC_length (varpool_node_ptr
, set
->nodes
);
1318 /* Insert into node vector. */
1319 VEC_safe_push (varpool_node_ptr
, gc
, set
->nodes
, node
);
1322 /* Remove varpool_node NODE from varpool_node_set SET. */
1325 varpool_node_set_remove (varpool_node_set set
, struct varpool_node
*node
)
1327 void **slot
, **last_slot
;
1328 varpool_node_set_element element
, last_element
;
1329 struct varpool_node
*last_node
;
1330 struct varpool_node_set_element_def dummy
;
1333 slot
= htab_find_slot (set
->hashtab
, &dummy
, NO_INSERT
);
1337 element
= (varpool_node_set_element
) *slot
;
1338 gcc_assert (VEC_index (varpool_node_ptr
, set
->nodes
, element
->index
)
1341 /* Remove from vector. We do this by swapping node with the last element
1343 last_node
= VEC_pop (varpool_node_ptr
, set
->nodes
);
1344 if (last_node
!= node
)
1346 dummy
.node
= last_node
;
1347 last_slot
= htab_find_slot (set
->hashtab
, &dummy
, NO_INSERT
);
1348 last_element
= (varpool_node_set_element
) *last_slot
;
1349 gcc_assert (last_element
);
1351 /* Move the last element to the original spot of NODE. */
1352 last_element
->index
= element
->index
;
1353 VEC_replace (varpool_node_ptr
, set
->nodes
, last_element
->index
,
1357 /* Remove element from hash table. */
1358 htab_clear_slot (set
->hashtab
, slot
);
1362 /* Find NODE in SET and return an iterator to it if found. A null iterator
1363 is returned if NODE is not in SET. */
1365 varpool_node_set_iterator
1366 varpool_node_set_find (varpool_node_set set
, struct varpool_node
*node
)
1369 struct varpool_node_set_element_def dummy
;
1370 varpool_node_set_element element
;
1371 varpool_node_set_iterator vsi
;
1374 slot
= htab_find_slot (set
->hashtab
, &dummy
, NO_INSERT
);
1376 vsi
.index
= (unsigned) ~0;
1379 element
= (varpool_node_set_element
) *slot
;
1380 gcc_assert (VEC_index (varpool_node_ptr
, set
->nodes
, element
->index
)
1382 vsi
.index
= element
->index
;
1389 /* Dump content of SET to file F. */
1392 dump_varpool_node_set (FILE *f
, varpool_node_set set
)
1394 varpool_node_set_iterator iter
;
1396 for (iter
= vsi_start (set
); !vsi_end_p (iter
); vsi_next (&iter
))
1398 struct varpool_node
*node
= vsi_node (iter
);
1399 fprintf (f
, " %s", varpool_node_name (node
));
1404 /* Dump content of SET to stderr. */
1407 debug_varpool_node_set (varpool_node_set set
)
1409 dump_varpool_node_set (stderr
, set
);
1413 /* Simple ipa profile pass propagating frequencies across the callgraph. */
1418 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1419 struct cgraph_edge
*e
;
1421 bool something_changed
= false;
1424 order_pos
= cgraph_postorder (order
);
1425 for (i
= order_pos
- 1; i
>= 0; i
--)
1427 if (order
[i
]->local
.local
&& cgraph_propagate_frequency (order
[i
]))
1429 for (e
= order
[i
]->callees
; e
; e
= e
->next_callee
)
1430 if (e
->callee
->local
.local
&& !e
->callee
->aux
)
1432 something_changed
= true;
1433 e
->callee
->aux
= (void *)1;
1436 order
[i
]->aux
= NULL
;
1439 while (something_changed
)
1441 something_changed
= false;
1442 for (i
= order_pos
- 1; i
>= 0; i
--)
1444 if (order
[i
]->aux
&& cgraph_propagate_frequency (order
[i
]))
1446 for (e
= order
[i
]->callees
; e
; e
= e
->next_callee
)
1447 if (e
->callee
->local
.local
&& !e
->callee
->aux
)
1449 something_changed
= true;
1450 e
->callee
->aux
= (void *)1;
1453 order
[i
]->aux
= NULL
;
1461 gate_ipa_profile (void)
1463 return flag_ipa_profile
;
1466 struct ipa_opt_pass_d pass_ipa_profile
=
1470 "ipa-profile", /* name */
1471 gate_ipa_profile
, /* gate */
1472 ipa_profile
, /* execute */
1475 0, /* static_pass_number */
1476 TV_IPA_PROFILE
, /* 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 */
1494 /* Generate and emit a static constructor or destructor. WHICH must
1495 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
1496 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
1497 initialization priority for this constructor or destructor.
1499 FINAL specify whether the externally visible name for collect2 should
1503 cgraph_build_static_cdtor_1 (char which
, tree body
, int priority
, bool final
)
1505 static int counter
= 0;
1507 tree decl
, name
, resdecl
;
1509 /* The priority is encoded in the constructor or destructor name.
1510 collect2 will sort the names and arrange that they are called at
1513 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
1515 /* Proudce sane name but one not recognizable by collect2, just for the
1516 case we fail to inline the function. */
1517 sprintf (which_buf
, "sub_%c_%.5d_%d", which
, priority
, counter
++);
1518 name
= get_file_function_name (which_buf
);
1520 decl
= build_decl (input_location
, FUNCTION_DECL
, name
,
1521 build_function_type_list (void_type_node
, NULL_TREE
));
1522 current_function_decl
= decl
;
1524 resdecl
= build_decl (input_location
,
1525 RESULT_DECL
, NULL_TREE
, void_type_node
);
1526 DECL_ARTIFICIAL (resdecl
) = 1;
1527 DECL_RESULT (decl
) = resdecl
;
1528 DECL_CONTEXT (resdecl
) = decl
;
1530 allocate_struct_function (decl
, false);
1532 TREE_STATIC (decl
) = 1;
1533 TREE_USED (decl
) = 1;
1534 DECL_ARTIFICIAL (decl
) = 1;
1535 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
1536 DECL_SAVED_TREE (decl
) = body
;
1537 if (!targetm
.have_ctors_dtors
&& final
)
1539 TREE_PUBLIC (decl
) = 1;
1540 DECL_PRESERVE_P (decl
) = 1;
1542 DECL_UNINLINABLE (decl
) = 1;
1544 DECL_INITIAL (decl
) = make_node (BLOCK
);
1545 TREE_USED (DECL_INITIAL (decl
)) = 1;
1547 DECL_SOURCE_LOCATION (decl
) = input_location
;
1548 cfun
->function_end_locus
= input_location
;
1553 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
1554 decl_init_priority_insert (decl
, priority
);
1557 DECL_STATIC_DESTRUCTOR (decl
) = 1;
1558 decl_fini_priority_insert (decl
, priority
);
1564 gimplify_function_tree (decl
);
1566 cgraph_add_new_function (decl
, false);
1569 current_function_decl
= NULL
;
1572 /* Generate and emit a static constructor or destructor. WHICH must
1573 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
1574 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
1575 initialization priority for this constructor or destructor. */
1578 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
1580 cgraph_build_static_cdtor_1 (which
, body
, priority
, false);
1583 /* A vector of FUNCTION_DECLs declared as static constructors. */
1584 static VEC(tree
, heap
) *static_ctors
;
1585 /* A vector of FUNCTION_DECLs declared as static destructors. */
1586 static VEC(tree
, heap
) *static_dtors
;
1588 /* When target does not have ctors and dtors, we call all constructor
1589 and destructor by special initialization/destruction function
1590 recognized by collect2.
1592 When we are going to build this function, collect all constructors and
1593 destructors and turn them into normal functions. */
1596 record_cdtor_fn (struct cgraph_node
*node
)
1598 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
1599 VEC_safe_push (tree
, heap
, static_ctors
, node
->decl
);
1600 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
1601 VEC_safe_push (tree
, heap
, static_dtors
, node
->decl
);
1602 node
= cgraph_node (node
->decl
);
1603 node
->local
.disregard_inline_limits
= 1;
1606 /* Define global constructors/destructor functions for the CDTORS, of
1607 which they are LEN. The CDTORS are sorted by initialization
1608 priority. If CTOR_P is true, these are constructors; otherwise,
1609 they are destructors. */
1612 build_cdtor (bool ctor_p
, VEC (tree
, heap
) *cdtors
)
1615 size_t len
= VEC_length (tree
, cdtors
);
1622 priority_type priority
;
1630 fn
= VEC_index (tree
, cdtors
, j
);
1631 p
= ctor_p
? DECL_INIT_PRIORITY (fn
) : DECL_FINI_PRIORITY (fn
);
1634 else if (p
!= priority
)
1640 /* When there is only one cdtor and target supports them, do nothing. */
1642 && targetm
.have_ctors_dtors
)
1647 /* Find the next batch of constructors/destructors with the same
1648 initialization priority. */
1652 fn
= VEC_index (tree
, cdtors
, i
);
1653 call
= build_call_expr (fn
, 0);
1655 DECL_STATIC_CONSTRUCTOR (fn
) = 0;
1657 DECL_STATIC_DESTRUCTOR (fn
) = 0;
1658 /* We do not want to optimize away pure/const calls here.
1659 When optimizing, these should be already removed, when not
1660 optimizing, we want user to be able to breakpoint in them. */
1661 TREE_SIDE_EFFECTS (call
) = 1;
1662 append_to_statement_list (call
, &body
);
1664 gcc_assert (body
!= NULL_TREE
);
1665 /* Generate a function to call all the function of like
1667 cgraph_build_static_cdtor_1 (ctor_p
? 'I' : 'D', body
, priority
, true);
1671 /* Comparison function for qsort. P1 and P2 are actually of type
1672 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
1673 used to determine the sort order. */
1676 compare_ctor (const void *p1
, const void *p2
)
1683 f1
= *(const tree
*)p1
;
1684 f2
= *(const tree
*)p2
;
1685 priority1
= DECL_INIT_PRIORITY (f1
);
1686 priority2
= DECL_INIT_PRIORITY (f2
);
1688 if (priority1
< priority2
)
1690 else if (priority1
> priority2
)
1693 /* Ensure a stable sort. Constructors are executed in backwarding
1694 order to make LTO initialize braries first. */
1695 return DECL_UID (f2
) - DECL_UID (f1
);
1698 /* Comparison function for qsort. P1 and P2 are actually of type
1699 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
1700 used to determine the sort order. */
1703 compare_dtor (const void *p1
, const void *p2
)
1710 f1
= *(const tree
*)p1
;
1711 f2
= *(const tree
*)p2
;
1712 priority1
= DECL_FINI_PRIORITY (f1
);
1713 priority2
= DECL_FINI_PRIORITY (f2
);
1715 if (priority1
< priority2
)
1717 else if (priority1
> priority2
)
1720 /* Ensure a stable sort. */
1721 return DECL_UID (f1
) - DECL_UID (f2
);
1724 /* Generate functions to call static constructors and destructors
1725 for targets that do not support .ctors/.dtors sections. These
1726 functions have magic names which are detected by collect2. */
1729 build_cdtor_fns (void)
1731 if (!VEC_empty (tree
, static_ctors
))
1733 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1734 VEC_qsort (tree
, static_ctors
, compare_ctor
);
1735 build_cdtor (/*ctor_p=*/true, static_ctors
);
1738 if (!VEC_empty (tree
, static_dtors
))
1740 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1741 VEC_qsort (tree
, static_dtors
, compare_dtor
);
1742 build_cdtor (/*ctor_p=*/false, static_dtors
);
1746 /* Look for constructors and destructors and produce function calling them.
1747 This is needed for targets not supporting ctors or dtors, but we perform the
1748 transformation also at linktime to merge possibly numberous
1749 constructors/destructors into single function to improve code locality and
1753 ipa_cdtor_merge (void)
1755 struct cgraph_node
*node
;
1756 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1758 && (DECL_STATIC_CONSTRUCTOR (node
->decl
)
1759 || DECL_STATIC_DESTRUCTOR (node
->decl
)))
1760 record_cdtor_fn (node
);
1762 VEC_free (tree
, heap
, static_ctors
);
1763 VEC_free (tree
, heap
, static_dtors
);
1767 /* Perform the pass when we have no ctors/dtors support
1768 or at LTO time to merge multiple constructors into single
1772 gate_ipa_cdtor_merge (void)
1774 return !targetm
.have_ctors_dtors
|| (optimize
&& in_lto_p
);
1777 struct ipa_opt_pass_d pass_ipa_cdtor_merge
=
1782 gate_ipa_cdtor_merge
, /* gate */
1783 ipa_cdtor_merge
, /* execute */
1786 0, /* static_pass_number */
1787 TV_CGRAPHOPT
, /* tv_id */
1788 0, /* properties_required */
1789 0, /* properties_provided */
1790 0, /* properties_destroyed */
1791 0, /* todo_flags_start */
1792 0 /* todo_flags_finish */
1794 NULL
, /* generate_summary */
1795 NULL
, /* write_summary */
1796 NULL
, /* read_summary */
1797 NULL
, /* write_optimization_summary */
1798 NULL
, /* read_optimization_summary */
1799 NULL
, /* stmt_fixup */
1801 NULL
, /* function_transform */
1802 NULL
/* variable_transform */