1 /* Basic IPA optimizations and utilities.
2 Copyright (C) 2003-2020 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
27 #include "alloc-pool.h"
28 #include "tree-pass.h"
29 #include "stringpool.h"
32 #include "tree-iterator.h"
33 #include "ipa-utils.h"
34 #include "symbol-summary.h"
37 #include "ipa-fnsummary.h"
40 #include "stringpool.h"
43 /* Return true when NODE has ADDR reference. */
46 has_addr_references_p (struct cgraph_node
*node
,
50 struct ipa_ref
*ref
= NULL
;
52 for (i
= 0; node
->iterate_referring (i
, ref
); i
++)
53 if (ref
->use
== IPA_REF_ADDR
)
58 /* Return true when NODE can be target of an indirect call. */
61 is_indirect_call_target_p (struct cgraph_node
*node
, void *)
63 return node
->indirect_call_target
;
66 /* Look for all functions inlined to NODE and update their inlined_to pointers
70 update_inlined_to_pointer (struct cgraph_node
*node
, struct cgraph_node
*inlined_to
)
72 struct cgraph_edge
*e
;
73 for (e
= node
->callees
; e
; e
= e
->next_callee
)
74 if (e
->callee
->inlined_to
)
76 e
->callee
->inlined_to
= inlined_to
;
77 update_inlined_to_pointer (e
->callee
, inlined_to
);
81 /* Add symtab NODE to queue starting at FIRST.
83 The queue is linked via AUX pointers and terminated by pointer to 1.
84 We enqueue nodes at two occasions: when we find them reachable or when we find
85 their bodies needed for further clonning. In the second case we mark them
86 by pointer to 2 after processing so they are re-queue when they become
90 enqueue_node (symtab_node
*node
, symtab_node
**first
,
91 hash_set
<symtab_node
*> *reachable
)
93 /* Node is still in queue; do nothing. */
94 if (node
->aux
&& node
->aux
!= (void *) 2)
96 /* Node was already processed as unreachable, re-enqueue
97 only if it became reachable now. */
98 if (node
->aux
== (void *)2 && !reachable
->contains (node
))
104 /* Return true if NODE may get inlined later.
105 This is used to keep DECL_EXTERNAL function bodies around long enough
106 so inliner can proces them. */
109 possible_inline_candidate_p (symtab_node
*node
)
111 if (symtab
->state
>= IPA_SSA_AFTER_INLINING
)
113 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
);
116 if (DECL_UNINLINABLE (cnode
->decl
))
118 if (opt_for_fn (cnode
->decl
, optimize
))
120 if (symtab
->state
>= IPA_SSA
)
122 return lookup_attribute ("always_inline", DECL_ATTRIBUTES (node
->decl
));
125 /* Process references. */
128 process_references (symtab_node
*snode
,
130 hash_set
<symtab_node
*> *reachable
)
133 struct ipa_ref
*ref
= NULL
;
134 for (i
= 0; snode
->iterate_reference (i
, ref
); i
++)
136 symtab_node
*node
= ref
->referred
;
137 symtab_node
*body
= node
->ultimate_alias_target ();
139 if (node
->definition
&& !node
->in_other_partition
140 && ((!DECL_EXTERNAL (node
->decl
) || node
->alias
)
141 || (possible_inline_candidate_p (node
)
142 /* We use variable constructors during late compilation for
143 constant folding. Keep references alive so partitioning
144 knows about potential references. */
145 || (VAR_P (node
->decl
)
147 || flag_incremental_link
148 == INCREMENTAL_LINK_LTO
)
149 && dyn_cast
<varpool_node
*> (node
)
150 ->ctor_useable_for_folding_p ()))))
152 /* Be sure that we will not optimize out alias target
154 if (DECL_EXTERNAL (node
->decl
)
156 && symtab
->state
< IPA_SSA_AFTER_INLINING
)
157 reachable
->add (body
);
158 reachable
->add (node
);
160 enqueue_node (node
, first
, reachable
);
164 /* EDGE is an polymorphic call. If BEFORE_INLINING_P is set, mark
165 all its potential targets as reachable to permit later inlining if
166 devirtualization happens. After inlining still keep their declarations
167 around, so we can devirtualize to a direct call.
169 Also try to make trivial devirutalization when no or only one target is
173 walk_polymorphic_call_targets (hash_set
<void *> *reachable_call_targets
,
174 struct cgraph_edge
*edge
,
176 hash_set
<symtab_node
*> *reachable
)
181 vec
<cgraph_node
*>targets
182 = possible_polymorphic_call_targets
183 (edge
, &final
, &cache_token
);
185 if (!reachable_call_targets
->add (cache_token
))
187 for (i
= 0; i
< targets
.length (); i
++)
189 struct cgraph_node
*n
= targets
[i
];
191 /* Do not bother to mark virtual methods in anonymous namespace;
192 either we will find use of virtual table defining it, or it is
194 if (TREE_CODE (TREE_TYPE (n
->decl
)) == METHOD_TYPE
195 && type_in_anonymous_namespace_p
196 (TYPE_METHOD_BASETYPE (TREE_TYPE (n
->decl
))))
199 n
->indirect_call_target
= true;
200 symtab_node
*body
= n
->function_symbol ();
202 /* Prior inlining, keep alive bodies of possible targets for
205 && (possible_inline_candidate_p (body
)
206 && opt_for_fn (body
->decl
, flag_devirtualize
)))
208 /* Be sure that we will not optimize out alias target
210 if (DECL_EXTERNAL (n
->decl
)
212 && symtab
->state
< IPA_SSA_AFTER_INLINING
)
213 reachable
->add (body
);
216 /* Even after inlining we want to keep the possible targets in the
217 boundary, so late passes can still produce direct call even if
218 the chance for inlining is lost. */
219 enqueue_node (n
, first
, reachable
);
223 /* Very trivial devirtualization; when the type is
224 final or anonymous (so we know all its derivation)
225 and there is only one possible virtual call target,
226 make the edge direct. */
229 if (targets
.length () <= 1 && dbg_cnt (devirt
))
231 cgraph_node
*target
, *node
= edge
->caller
;
232 if (targets
.length () == 1)
235 target
= cgraph_node::get_create
236 (builtin_decl_implicit (BUILT_IN_UNREACHABLE
));
238 if (dump_enabled_p ())
240 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, edge
->call_stmt
,
241 "devirtualizing call in %s to %s\n",
242 edge
->caller
->dump_name (),
243 target
->dump_name ());
245 edge
= cgraph_edge::make_direct (edge
, target
);
246 if (ipa_fn_summaries
)
247 ipa_update_overall_fn_summary (node
->inlined_to
248 ? node
->inlined_to
: node
);
249 else if (edge
->call_stmt
)
250 cgraph_edge::redirect_call_stmt_to_callee (edge
);
255 /* Perform reachability analysis and reclaim all unreachable nodes.
257 The algorithm is basically mark&sweep but with some extra refinements:
259 - reachable extern inline functions needs special handling; the bodies needs
260 to stay in memory until inlining in hope that they will be inlined.
261 After inlining we release their bodies and turn them into unanalyzed
262 nodes even when they are reachable.
264 - virtual functions are kept in callgraph even if they seem unreachable in
265 hope calls to them will be devirtualized.
267 Again we remove them after inlining. In late optimization some
268 devirtualization may happen, but it is not important since we won't inline
269 the call. In theory early opts and IPA should work out all important cases.
271 - virtual clones needs bodies of their origins for later materialization;
272 this means that we want to keep the body even if the origin is unreachable
273 otherwise. To avoid origin from sitting in the callgraph and being
274 walked by IPA passes, we turn them into unanalyzed nodes with body
277 We maintain set of function declaration where body needs to stay in
278 body_needed_for_clonning
280 Inline clones represent special case: their declaration match the
281 declaration of origin and cgraph_remove_node already knows how to
282 reshape callgraph and preserve body when offline copy of function or
283 inline clone is being removed.
285 - C++ virtual tables keyed to other unit are represented as DECL_EXTERNAL
286 variables with DECL_INITIAL set. We finalize these and keep reachable
287 ones around for constant folding purposes. After inlining we however
288 stop walking their references to let everything static referneced by them
289 to be removed when it is otherwise unreachable.
291 We maintain queue of both reachable symbols (i.e. defined symbols that needs
292 to stay) and symbols that are in boundary (i.e. external symbols referenced
293 by reachable symbols or origins of clones). The queue is represented
294 as linked list by AUX pointer terminated by 1.
296 At the end we keep all reachable symbols. For symbols in boundary we always
297 turn definition into a declaration, but we may keep function body around
298 based on body_needed_for_clonning
300 All symbols that enter the queue have AUX pointer non-zero and are in the
301 boundary. Pointer set REACHABLE is used to track reachable symbols.
303 Every symbol can be visited twice - once as part of boundary and once
304 as real reachable symbol. enqueue_node needs to decide whether the
305 node needs to be re-queued for second processing. For this purpose
306 we set AUX pointer of processed symbols in the boundary to constant 2. */
309 symbol_table::remove_unreachable_nodes (FILE *file
)
311 symtab_node
*first
= (symtab_node
*) (void *) 1;
312 struct cgraph_node
*node
, *next
;
313 varpool_node
*vnode
, *vnext
;
314 bool changed
= false;
315 hash_set
<symtab_node
*> reachable
;
316 hash_set
<tree
> body_needed_for_clonning
;
317 hash_set
<void *> reachable_call_targets
;
319 timevar_push (TV_IPA_UNREACHABLE
);
320 build_type_inheritance_graph ();
322 fprintf (file
, "\nReclaiming functions:");
325 FOR_EACH_FUNCTION (node
)
326 gcc_assert (!node
->aux
);
327 FOR_EACH_VARIABLE (vnode
)
328 gcc_assert (!vnode
->aux
);
330 /* Mark functions whose bodies are obviously needed.
331 This is mostly when they can be referenced externally. Inline clones
332 are special since their declarations are shared with master clone and thus
333 cgraph_can_remove_if_no_direct_calls_and_refs_p should not be called on them. */
334 FOR_EACH_FUNCTION (node
)
336 node
->used_as_abstract_origin
= false;
337 node
->indirect_call_target
= false;
340 && !node
->in_other_partition
341 && !node
->can_remove_if_no_direct_calls_and_refs_p ())
343 gcc_assert (!node
->inlined_to
);
344 reachable
.add (node
);
345 enqueue_node (node
, &first
, &reachable
);
348 gcc_assert (!node
->aux
);
351 /* Mark variables that are obviously needed. */
352 FOR_EACH_DEFINED_VARIABLE (vnode
)
353 if (!vnode
->can_remove_if_no_refs_p()
354 && !vnode
->in_other_partition
)
356 reachable
.add (vnode
);
357 enqueue_node (vnode
, &first
, &reachable
);
360 /* Perform reachability analysis. */
361 while (first
!= (symtab_node
*) (void *) 1)
363 bool in_boundary_p
= !reachable
.contains (first
);
364 symtab_node
*node
= first
;
366 first
= (symtab_node
*)first
->aux
;
368 /* If we are processing symbol in boundary, mark its AUX pointer for
369 possible later re-processing in enqueue_node. */
372 node
->aux
= (void *)2;
373 if (node
->alias
&& node
->analyzed
)
374 enqueue_node (node
->get_alias_target (), &first
, &reachable
);
378 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
379 && DECL_ABSTRACT_ORIGIN (node
->decl
))
381 struct cgraph_node
*origin_node
382 = cgraph_node::get (DECL_ABSTRACT_ORIGIN (node
->decl
));
383 if (origin_node
&& !origin_node
->used_as_abstract_origin
)
385 origin_node
->used_as_abstract_origin
= true;
386 gcc_assert (!origin_node
->prev_sibling_clone
);
387 gcc_assert (!origin_node
->next_sibling_clone
);
388 for (cgraph_node
*n
= origin_node
->clones
; n
;
389 n
= n
->next_sibling_clone
)
390 if (n
->decl
== DECL_ABSTRACT_ORIGIN (node
->decl
))
391 n
->used_as_abstract_origin
= true;
394 /* If any non-external and non-local symbol in a comdat group is
395 reachable, force all externally visible symbols in the same comdat
396 group to be reachable as well. Comdat-local symbols
397 can be discarded if all uses were inlined. */
398 if (node
->same_comdat_group
399 && node
->externally_visible
400 && !DECL_EXTERNAL (node
->decl
))
403 for (next
= node
->same_comdat_group
;
405 next
= next
->same_comdat_group
)
406 if (!next
->comdat_local_p ()
407 && !DECL_EXTERNAL (next
->decl
)
408 && !reachable
.add (next
))
409 enqueue_node (next
, &first
, &reachable
);
411 /* Mark references as reachable. */
412 process_references (node
, &first
, &reachable
);
415 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
))
417 /* Mark the callees reachable unless they are direct calls to extern
418 inline functions we decided to not inline. */
421 struct cgraph_edge
*e
;
422 /* Keep alive possible targets for devirtualization. */
423 if (opt_for_fn (cnode
->decl
, optimize
)
424 && opt_for_fn (cnode
->decl
, flag_devirtualize
))
426 struct cgraph_edge
*next
;
427 for (e
= cnode
->indirect_calls
; e
; e
= next
)
429 next
= e
->next_callee
;
430 if (e
->indirect_info
->polymorphic
)
431 walk_polymorphic_call_targets (&reachable_call_targets
,
432 e
, &first
, &reachable
);
435 for (e
= cnode
->callees
; e
; e
= e
->next_callee
)
437 symtab_node
*body
= e
->callee
->function_symbol ();
438 if (e
->callee
->definition
439 && !e
->callee
->in_other_partition
440 && (!e
->inline_failed
441 || !DECL_EXTERNAL (e
->callee
->decl
)
443 || possible_inline_candidate_p (e
->callee
)))
445 /* Be sure that we will not optimize out alias target
447 if (DECL_EXTERNAL (e
->callee
->decl
)
449 && symtab
->state
< IPA_SSA_AFTER_INLINING
)
450 reachable
.add (body
);
451 reachable
.add (e
->callee
);
453 else if (e
->callee
->declare_variant_alt
454 && !e
->callee
->in_other_partition
)
455 reachable
.add (e
->callee
);
456 enqueue_node (e
->callee
, &first
, &reachable
);
459 /* When inline clone exists, mark body to be preserved so when removing
460 offline copy of the function we don't kill it. */
461 if (cnode
->inlined_to
)
462 body_needed_for_clonning
.add (cnode
->decl
);
464 /* For non-inline clones, force their origins to the boundary and ensure
465 that body is not removed. */
466 while (cnode
->clone_of
)
468 bool noninline
= cnode
->clone_of
->decl
!= cnode
->decl
;
469 cnode
= cnode
->clone_of
;
472 body_needed_for_clonning
.add (cnode
->decl
);
473 enqueue_node (cnode
, &first
, &reachable
);
478 else if (cnode
->thunk
)
479 enqueue_node (cnode
->callees
->callee
, &first
, &reachable
);
481 /* If any reachable function has simd clones, mark them as
482 reachable as well. */
483 if (cnode
->simd_clones
)
486 for (next
= cnode
->simd_clones
;
488 next
= next
->simdclone
->next_clone
)
490 || !reachable
.add (next
))
491 enqueue_node (next
, &first
, &reachable
);
494 /* When we see constructor of external variable, keep referred nodes in the
495 boundary. This will also hold initializers of the external vars NODE
497 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
499 && DECL_EXTERNAL (node
->decl
)
503 struct ipa_ref
*ref
= NULL
;
504 for (int i
= 0; node
->iterate_reference (i
, ref
); i
++)
505 enqueue_node (ref
->referred
, &first
, &reachable
);
509 /* Remove unreachable functions. */
510 for (node
= first_function (); node
; node
= next
)
512 next
= next_function (node
);
514 /* If node is not needed at all, remove it. */
518 fprintf (file
, " %s", node
->dump_name ());
522 /* If node is unreachable, remove its body. */
523 else if (!reachable
.contains (node
))
525 /* We keep definitions of thunks and aliases in the boundary so
526 we can walk to the ultimate alias targets and function symbols
528 if (node
->alias
|| node
->thunk
)
530 else if (!body_needed_for_clonning
.contains (node
->decl
))
532 /* Make the node a non-clone so that we do not attempt to
533 materialize it later. */
535 node
->remove_from_clone_tree ();
536 node
->release_body ();
538 else if (!node
->clone_of
)
539 gcc_assert (in_lto_p
|| DECL_RESULT (node
->decl
));
540 if (node
->definition
&& !node
->alias
&& !node
->thunk
)
543 fprintf (file
, " %s", node
->dump_name ());
544 node
->body_removed
= true;
545 node
->analyzed
= false;
546 node
->definition
= false;
547 node
->cpp_implicit_alias
= false;
549 node
->transparent_alias
= false;
551 node
->weakref
= false;
552 /* After early inlining we drop always_inline attributes on
553 bodies of functions that are still referenced (have their
555 DECL_ATTRIBUTES (node
->decl
)
556 = remove_attribute ("always_inline",
557 DECL_ATTRIBUTES (node
->decl
));
558 if (!node
->in_other_partition
)
560 node
->remove_callees ();
561 node
->remove_all_references ();
566 gcc_assert (node
->clone_of
|| !node
->has_gimple_body_p ()
567 || in_lto_p
|| DECL_RESULT (node
->decl
));
570 /* Inline clones might be kept around so their materializing allows further
571 cloning. If the function the clone is inlined into is removed, we need
572 to turn it into normal cone. */
573 FOR_EACH_FUNCTION (node
)
578 gcc_assert (node
->clones
);
579 node
->inlined_to
= NULL
;
580 update_inlined_to_pointer (node
, node
);
585 /* Remove unreachable variables. */
587 fprintf (file
, "\nReclaiming variables:");
588 for (vnode
= first_variable (); vnode
; vnode
= vnext
)
590 vnext
= next_variable (vnode
);
592 /* For can_refer_decl_in_current_unit_p we want to track for
593 all external variables if they are defined in other partition
595 && (!flag_ltrans
|| !DECL_EXTERNAL (vnode
->decl
)))
597 struct ipa_ref
*ref
= NULL
;
599 /* First remove the aliases, so varpool::remove can possibly lookup
600 the constructor and save it for future use. */
601 while (vnode
->iterate_direct_aliases (0, ref
))
604 fprintf (file
, " %s", ref
->referred
->dump_name ());
605 ref
->referring
->remove ();
608 fprintf (file
, " %s", vnode
->dump_name ());
609 vnext
= next_variable (vnode
);
610 /* Signal removal to the debug machinery. */
611 if (! flag_wpa
|| flag_incremental_link
== INCREMENTAL_LINK_LTO
)
613 vnode
->definition
= false;
614 (*debug_hooks
->late_global_decl
) (vnode
->decl
);
619 else if (!reachable
.contains (vnode
) && !vnode
->alias
)
622 if (vnode
->definition
)
625 fprintf (file
, " %s", vnode
->dump_name ());
628 /* Keep body if it may be useful for constant folding. */
629 if ((flag_wpa
|| flag_incremental_link
== INCREMENTAL_LINK_LTO
)
630 || ((init
= ctor_for_folding (vnode
->decl
)) == error_mark_node
))
631 vnode
->remove_initializer ();
633 DECL_INITIAL (vnode
->decl
) = init
;
634 vnode
->body_removed
= true;
635 vnode
->definition
= false;
636 vnode
->analyzed
= false;
639 vnode
->remove_from_same_comdat_group ();
641 vnode
->remove_all_references ();
647 /* Now update address_taken flags and try to promote functions to be local. */
649 fprintf (file
, "\nClearing address taken flags:");
650 FOR_EACH_DEFINED_FUNCTION (node
)
651 if (node
->address_taken
652 && !node
->used_from_other_partition
)
654 if (!node
->call_for_symbol_and_aliases
655 (has_addr_references_p
, NULL
, true))
658 fprintf (file
, " %s", node
->dump_name ());
659 node
->address_taken
= false;
662 /* Virtual functions may be kept in cgraph just because
663 of possible later devirtualization. Do not mark them as
664 local too early so we won't optimize them out before
665 we are done with polymorphic call analysis. */
666 && (symtab
->state
>= IPA_SSA_AFTER_INLINING
667 || !node
->call_for_symbol_and_aliases
668 (is_indirect_call_target_p
, NULL
, true)))
672 fprintf (file
, " (local)");
677 fprintf (file
, "\n");
679 symtab_node::checking_verify_symtab_nodes ();
681 /* If we removed something, perhaps profile could be improved. */
682 if (changed
&& (optimize
|| in_lto_p
) && ipa_call_summaries
)
683 FOR_EACH_DEFINED_FUNCTION (node
)
684 ipa_propagate_frequency (node
);
686 timevar_pop (TV_IPA_UNREACHABLE
);
690 /* Process references to VNODE and set flags WRITTEN, ADDRESS_TAKEN, READ
691 as needed, also clear EXPLICIT_REFS if the references to given variable
692 do not need to be explicit. */
695 process_references (varpool_node
*vnode
,
696 bool *written
, bool *address_taken
,
697 bool *read
, bool *explicit_refs
)
702 if (!vnode
->all_refs_explicit_p ()
703 || TREE_THIS_VOLATILE (vnode
->decl
))
704 *explicit_refs
= false;
706 for (i
= 0; vnode
->iterate_referring (i
, ref
)
707 && *explicit_refs
&& (!*written
|| !*address_taken
|| !*read
); i
++)
711 *address_taken
= true;
720 process_references (dyn_cast
<varpool_node
*> (ref
->referring
), written
,
721 address_taken
, read
, explicit_refs
);
726 /* Set TREE_READONLY bit. */
729 set_readonly_bit (varpool_node
*vnode
, void *data ATTRIBUTE_UNUSED
)
731 TREE_READONLY (vnode
->decl
) = true;
735 /* Set writeonly bit and clear the initalizer, since it will not be needed. */
738 set_writeonly_bit (varpool_node
*vnode
, void *data
)
740 vnode
->writeonly
= true;
741 if (optimize
|| in_lto_p
)
743 DECL_INITIAL (vnode
->decl
) = NULL
;
746 if (vnode
->num_references ())
747 *(bool *)data
= true;
748 vnode
->remove_all_references ();
754 /* Clear addressale bit of VNODE. */
757 clear_addressable_bit (varpool_node
*vnode
, void *data ATTRIBUTE_UNUSED
)
759 vnode
->address_taken
= false;
760 TREE_ADDRESSABLE (vnode
->decl
) = 0;
764 /* Discover variables that have no longer address taken, are read-only or
765 write-only and update their flags.
767 Return true when unreachable symbol removal should be done.
769 FIXME: This cannot be done in between gimplify and omp_expand since
770 readonly flag plays role on what is shared and what is not. Currently we do
771 this transformation as part of whole program visibility and re-do at
772 ipa-reference pass (to take into account clonning), but it would
773 make sense to do it before early optimizations. */
776 ipa_discover_variable_flags (void)
778 if (!flag_ipa_reference_addressable
)
781 bool remove_p
= false;
784 fprintf (dump_file
, "Clearing variable flags:");
785 FOR_EACH_VARIABLE (vnode
)
787 && (TREE_ADDRESSABLE (vnode
->decl
)
789 || !TREE_READONLY (vnode
->decl
)))
791 bool written
= false;
792 bool address_taken
= false;
794 bool explicit_refs
= true;
796 process_references (vnode
, &written
, &address_taken
, &read
,
802 if (TREE_ADDRESSABLE (vnode
->decl
) && dump_file
)
803 fprintf (dump_file
, " %s (non-addressable)",
804 vnode
->dump_name ());
805 vnode
->call_for_symbol_and_aliases (clear_addressable_bit
, NULL
,
808 if (!address_taken
&& !written
809 /* Making variable in explicit section readonly can cause section
811 See e.g. gcc.c-torture/compile/pr23237.c */
812 && vnode
->get_section () == NULL
)
814 if (!TREE_READONLY (vnode
->decl
) && dump_file
)
815 fprintf (dump_file
, " %s (read-only)", vnode
->dump_name ());
816 vnode
->call_for_symbol_and_aliases (set_readonly_bit
, NULL
, true);
818 if (!vnode
->writeonly
&& !read
&& !address_taken
&& written
)
821 fprintf (dump_file
, " %s (write-only)", vnode
->dump_name ());
822 vnode
->call_for_symbol_and_aliases (set_writeonly_bit
, &remove_p
,
827 fprintf (dump_file
, "\n");
831 /* Generate and emit a static constructor or destructor. WHICH must
832 be one of 'I' (for a constructor), 'D' (for a destructor).
833 BODY is a STATEMENT_LIST containing GENERIC
834 statements. PRIORITY is the initialization priority for this
835 constructor or destructor.
837 FINAL specify whether the externally visible name for collect2 should
841 cgraph_build_static_cdtor_1 (char which
, tree body
, int priority
, bool final
,
845 static int counter
= 0;
847 tree decl
, name
, resdecl
;
849 /* The priority is encoded in the constructor or destructor name.
850 collect2 will sort the names and arrange that they are called at
852 if (!targetm
.have_ctors_dtors
&& final
)
854 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
855 name
= get_file_function_name (which_buf
);
859 /* Proudce sane name but one not recognizable by collect2, just for the
860 case we fail to inline the function. */
861 sprintf (which_buf
, "_sub_%c_%.5d_%d", which
, priority
, counter
++);
862 name
= get_identifier (which_buf
);
865 decl
= build_decl (input_location
, FUNCTION_DECL
, name
,
866 build_function_type_list (void_type_node
, NULL_TREE
));
867 current_function_decl
= decl
;
869 resdecl
= build_decl (input_location
,
870 RESULT_DECL
, NULL_TREE
, void_type_node
);
871 DECL_ARTIFICIAL (resdecl
) = 1;
872 DECL_RESULT (decl
) = resdecl
;
873 DECL_CONTEXT (resdecl
) = decl
;
875 allocate_struct_function (decl
, false);
877 TREE_STATIC (decl
) = 1;
878 TREE_USED (decl
) = 1;
879 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl
) = optimization
;
880 DECL_FUNCTION_SPECIFIC_TARGET (decl
) = target
;
881 DECL_ARTIFICIAL (decl
) = 1;
882 DECL_IGNORED_P (decl
) = 1;
883 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
884 DECL_SAVED_TREE (decl
) = body
;
885 if (!targetm
.have_ctors_dtors
&& final
)
887 TREE_PUBLIC (decl
) = 1;
888 DECL_PRESERVE_P (decl
) = 1;
890 DECL_UNINLINABLE (decl
) = 1;
892 DECL_INITIAL (decl
) = make_node (BLOCK
);
893 BLOCK_SUPERCONTEXT (DECL_INITIAL (decl
)) = decl
;
894 TREE_USED (DECL_INITIAL (decl
)) = 1;
896 DECL_SOURCE_LOCATION (decl
) = input_location
;
897 cfun
->function_end_locus
= input_location
;
902 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
903 decl_init_priority_insert (decl
, priority
);
906 DECL_STATIC_DESTRUCTOR (decl
) = 1;
907 decl_fini_priority_insert (decl
, priority
);
913 gimplify_function_tree (decl
);
915 cgraph_node::add_new_function (decl
, false);
918 current_function_decl
= NULL
;
921 /* Generate and emit a static constructor or destructor. WHICH must
922 be one of 'I' (for a constructor) or 'D' (for a destructor).
923 BODY is a STATEMENT_LIST containing GENERIC
924 statements. PRIORITY is the initialization priority for this
925 constructor or destructor. */
928 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
930 /* FIXME: We should be able to
931 gcc_assert (!in_lto_p);
932 because at LTO time the global options are not safe to use.
933 Unfortunately ASAN finish_file will produce constructors late and they
934 may lead to surprises. */
935 cgraph_build_static_cdtor_1 (which
, body
, priority
, false,
936 optimization_default_node
,
937 target_option_default_node
);
940 /* When target does not have ctors and dtors, we call all constructor
941 and destructor by special initialization/destruction function
942 recognized by collect2.
944 When we are going to build this function, collect all constructors and
945 destructors and turn them into normal functions. */
948 record_cdtor_fn (struct cgraph_node
*node
, vec
<tree
> *ctors
, vec
<tree
> *dtors
)
950 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
951 ctors
->safe_push (node
->decl
);
952 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
953 dtors
->safe_push (node
->decl
);
954 node
= cgraph_node::get (node
->decl
);
955 DECL_DISREGARD_INLINE_LIMITS (node
->decl
) = 1;
958 /* Define global constructors/destructor functions for the CDTORS, of
959 which they are LEN. The CDTORS are sorted by initialization
960 priority. If CTOR_P is true, these are constructors; otherwise,
961 they are destructors. */
964 build_cdtor (bool ctor_p
, const vec
<tree
> &cdtors
)
967 size_t len
= cdtors
.length ();
974 priority_type priority
;
983 p
= ctor_p
? DECL_INIT_PRIORITY (fn
) : DECL_FINI_PRIORITY (fn
);
986 else if (p
!= priority
)
992 /* When there is only one cdtor and target supports them, do nothing. */
994 && targetm
.have_ctors_dtors
)
999 /* Find the next batch of constructors/destructors with the same
1000 initialization priority. */
1005 call
= build_call_expr (fn
, 0);
1007 DECL_STATIC_CONSTRUCTOR (fn
) = 0;
1009 DECL_STATIC_DESTRUCTOR (fn
) = 0;
1010 /* We do not want to optimize away pure/const calls here.
1011 When optimizing, these should be already removed, when not
1012 optimizing, we want user to be able to breakpoint in them. */
1013 TREE_SIDE_EFFECTS (call
) = 1;
1014 append_to_statement_list (call
, &body
);
1016 gcc_assert (body
!= NULL_TREE
);
1017 /* Generate a function to call all the function of like
1019 cgraph_build_static_cdtor_1 (ctor_p
? 'I' : 'D', body
, priority
, true,
1020 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (cdtors
[0]),
1021 DECL_FUNCTION_SPECIFIC_TARGET (cdtors
[0]));
1025 /* Comparison function for qsort. P1 and P2 are actually of type
1026 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
1027 used to determine the sort order. */
1030 compare_ctor (const void *p1
, const void *p2
)
1037 f1
= *(const tree
*)p1
;
1038 f2
= *(const tree
*)p2
;
1039 priority1
= DECL_INIT_PRIORITY (f1
);
1040 priority2
= DECL_INIT_PRIORITY (f2
);
1042 if (priority1
< priority2
)
1044 else if (priority1
> priority2
)
1047 /* Ensure a stable sort. Constructors are executed in backwarding
1048 order to make LTO initialize braries first. */
1049 return DECL_UID (f2
) - DECL_UID (f1
);
1052 /* Comparison function for qsort. P1 and P2 are actually of type
1053 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
1054 used to determine the sort order. */
1057 compare_dtor (const void *p1
, const void *p2
)
1064 f1
= *(const tree
*)p1
;
1065 f2
= *(const tree
*)p2
;
1066 priority1
= DECL_FINI_PRIORITY (f1
);
1067 priority2
= DECL_FINI_PRIORITY (f2
);
1069 if (priority1
< priority2
)
1071 else if (priority1
> priority2
)
1074 /* Ensure a stable sort. */
1075 return DECL_UID (f1
) - DECL_UID (f2
);
1078 /* Generate functions to call static constructors and destructors
1079 for targets that do not support .ctors/.dtors sections. These
1080 functions have magic names which are detected by collect2. */
1083 build_cdtor_fns (vec
<tree
> *ctors
, vec
<tree
> *dtors
)
1085 if (!ctors
->is_empty ())
1087 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1088 ctors
->qsort (compare_ctor
);
1089 build_cdtor (/*ctor_p=*/true, *ctors
);
1092 if (!dtors
->is_empty ())
1094 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1095 dtors
->qsort (compare_dtor
);
1096 build_cdtor (/*ctor_p=*/false, *dtors
);
1100 /* Look for constructors and destructors and produce function calling them.
1101 This is needed for targets not supporting ctors or dtors, but we perform the
1102 transformation also at linktime to merge possibly numerous
1103 constructors/destructors into single function to improve code locality and
1107 ipa_cdtor_merge (void)
1109 /* A vector of FUNCTION_DECLs declared as static constructors. */
1110 auto_vec
<tree
, 20> ctors
;
1111 /* A vector of FUNCTION_DECLs declared as static destructors. */
1112 auto_vec
<tree
, 20> dtors
;
1113 struct cgraph_node
*node
;
1114 FOR_EACH_DEFINED_FUNCTION (node
)
1115 if (DECL_STATIC_CONSTRUCTOR (node
->decl
)
1116 || DECL_STATIC_DESTRUCTOR (node
->decl
))
1117 record_cdtor_fn (node
, &ctors
, &dtors
);
1118 build_cdtor_fns (&ctors
, &dtors
);
1124 const pass_data pass_data_ipa_cdtor_merge
=
1126 IPA_PASS
, /* type */
1128 OPTGROUP_NONE
, /* optinfo_flags */
1129 TV_CGRAPHOPT
, /* tv_id */
1130 0, /* properties_required */
1131 0, /* properties_provided */
1132 0, /* properties_destroyed */
1133 0, /* todo_flags_start */
1134 0, /* todo_flags_finish */
1137 class pass_ipa_cdtor_merge
: public ipa_opt_pass_d
1140 pass_ipa_cdtor_merge (gcc::context
*ctxt
)
1141 : ipa_opt_pass_d (pass_data_ipa_cdtor_merge
, ctxt
,
1142 NULL
, /* generate_summary */
1143 NULL
, /* write_summary */
1144 NULL
, /* read_summary */
1145 NULL
, /* write_optimization_summary */
1146 NULL
, /* read_optimization_summary */
1147 NULL
, /* stmt_fixup */
1148 0, /* function_transform_todo_flags_start */
1149 NULL
, /* function_transform */
1150 NULL
) /* variable_transform */
1153 /* opt_pass methods: */
1154 virtual bool gate (function
*);
1155 virtual unsigned int execute (function
*) { return ipa_cdtor_merge (); }
1157 }; // class pass_ipa_cdtor_merge
1160 pass_ipa_cdtor_merge::gate (function
*)
1162 /* Perform the pass when we have no ctors/dtors support
1163 or at LTO time to merge multiple constructors into single
1165 return !targetm
.have_ctors_dtors
|| in_lto_p
;
1171 make_pass_ipa_cdtor_merge (gcc::context
*ctxt
)
1173 return new pass_ipa_cdtor_merge (ctxt
);
1176 /* Invalid pointer representing BOTTOM for single user dataflow. */
1177 #define BOTTOM ((cgraph_node *)(size_t) 2)
1179 /* Meet operation for single user dataflow.
1180 Here we want to associate variables with sigle function that may access it.
1182 FUNCTION is current single user of a variable, VAR is variable that uses it.
1183 Latttice is stored in SINGLE_USER_MAP.
1186 - TOP by no entry in SIGNLE_USER_MAP
1187 - BOTTOM by BOTTOM in AUX pointer (to save lookups)
1188 - known single user by cgraph pointer in SINGLE_USER_MAP. */
1191 meet (cgraph_node
*function
, varpool_node
*var
,
1192 hash_map
<varpool_node
*, cgraph_node
*> &single_user_map
)
1194 struct cgraph_node
*user
, **f
;
1196 if (var
->aux
== BOTTOM
)
1199 f
= single_user_map
.get (var
);
1205 else if (function
!= user
)
1211 /* Propagation step of single-use dataflow.
1213 Check all uses of VNODE and see if they are used by single function FUNCTION.
1214 SINGLE_USER_MAP represents the dataflow lattice. */
1217 propagate_single_user (varpool_node
*vnode
, cgraph_node
*function
,
1218 hash_map
<varpool_node
*, cgraph_node
*> &single_user_map
)
1221 struct ipa_ref
*ref
;
1223 gcc_assert (!vnode
->externally_visible
);
1225 /* If node is an alias, first meet with its target. */
1227 function
= meet (function
, vnode
->get_alias_target (), single_user_map
);
1229 /* Check all users and see if they correspond to a single function. */
1230 for (i
= 0; vnode
->iterate_referring (i
, ref
) && function
!= BOTTOM
; i
++)
1232 struct cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (ref
->referring
);
1235 if (cnode
->inlined_to
)
1236 cnode
= cnode
->inlined_to
;
1239 else if (function
!= cnode
)
1243 function
= meet (function
, dyn_cast
<varpool_node
*> (ref
->referring
),
1249 /* Pass setting used_by_single_function flag.
1250 This flag is set on variable when there is only one function that may
1251 possibly referr to it. */
1254 ipa_single_use (void)
1256 varpool_node
*first
= (varpool_node
*) (void *) 1;
1258 hash_map
<varpool_node
*, cgraph_node
*> single_user_map
;
1260 FOR_EACH_DEFINED_VARIABLE (var
)
1261 if (!var
->all_refs_explicit_p ())
1265 /* Enqueue symbol for dataflow. */
1270 /* The actual dataflow. */
1272 while (first
!= (void *) 1)
1274 cgraph_node
*user
, *orig_user
, **f
;
1277 first
= (varpool_node
*)first
->aux
;
1279 f
= single_user_map
.get (var
);
1284 user
= propagate_single_user (var
, orig_user
, single_user_map
);
1286 gcc_checking_assert (var
->aux
!= BOTTOM
);
1288 /* If user differs, enqueue all references. */
1289 if (user
!= orig_user
)
1294 single_user_map
.put (var
, user
);
1296 /* Enqueue all aliases for re-processing. */
1297 for (i
= 0; var
->iterate_direct_aliases (i
, ref
); i
++)
1298 if (!ref
->referring
->aux
)
1300 ref
->referring
->aux
= first
;
1301 first
= dyn_cast
<varpool_node
*> (ref
->referring
);
1303 /* Enqueue all users for re-processing. */
1304 for (i
= 0; var
->iterate_reference (i
, ref
); i
++)
1305 if (!ref
->referred
->aux
1306 && ref
->referred
->definition
1307 && is_a
<varpool_node
*> (ref
->referred
))
1309 ref
->referred
->aux
= first
;
1310 first
= dyn_cast
<varpool_node
*> (ref
->referred
);
1313 /* If user is BOTTOM, just punt on this var. */
1323 FOR_EACH_DEFINED_VARIABLE (var
)
1325 if (var
->aux
!= BOTTOM
)
1327 /* Not having the single user known means that the VAR is
1328 unreachable. Either someone forgot to remove unreachable
1329 variables or the reachability here is wrong. */
1331 gcc_checking_assert (single_user_map
.get (var
));
1335 fprintf (dump_file
, "Variable %s is used by single function\n",
1338 var
->used_by_single_function
= true;
1347 const pass_data pass_data_ipa_single_use
=
1349 IPA_PASS
, /* type */
1350 "single-use", /* name */
1351 OPTGROUP_NONE
, /* optinfo_flags */
1352 TV_CGRAPHOPT
, /* tv_id */
1353 0, /* properties_required */
1354 0, /* properties_provided */
1355 0, /* properties_destroyed */
1356 0, /* todo_flags_start */
1357 0, /* todo_flags_finish */
1360 class pass_ipa_single_use
: public ipa_opt_pass_d
1363 pass_ipa_single_use (gcc::context
*ctxt
)
1364 : ipa_opt_pass_d (pass_data_ipa_single_use
, ctxt
,
1365 NULL
, /* generate_summary */
1366 NULL
, /* write_summary */
1367 NULL
, /* read_summary */
1368 NULL
, /* write_optimization_summary */
1369 NULL
, /* read_optimization_summary */
1370 NULL
, /* stmt_fixup */
1371 0, /* function_transform_todo_flags_start */
1372 NULL
, /* function_transform */
1373 NULL
) /* variable_transform */
1376 /* opt_pass methods: */
1377 virtual unsigned int execute (function
*) { return ipa_single_use (); }
1379 }; // class pass_ipa_single_use
1384 make_pass_ipa_single_use (gcc::context
*ctxt
)
1386 return new pass_ipa_single_use (ctxt
);