1 /* Basic IPA optimizations and utilities.
2 Copyright (C) 2003-2019 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
->global
.inlined_to
)
76 e
->callee
->global
.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
= edge
->make_direct (target
);
246 if (ipa_fn_summaries
)
247 ipa_update_overall_fn_summary (node
);
248 else if (edge
->call_stmt
)
249 edge
->redirect_call_stmt_to_callee ();
254 /* Perform reachability analysis and reclaim all unreachable nodes.
256 The algorithm is basically mark&sweep but with some extra refinements:
258 - reachable extern inline functions needs special handling; the bodies needs
259 to stay in memory until inlining in hope that they will be inlined.
260 After inlining we release their bodies and turn them into unanalyzed
261 nodes even when they are reachable.
263 - virtual functions are kept in callgraph even if they seem unreachable in
264 hope calls to them will be devirtualized.
266 Again we remove them after inlining. In late optimization some
267 devirtualization may happen, but it is not important since we won't inline
268 the call. In theory early opts and IPA should work out all important cases.
270 - virtual clones needs bodies of their origins for later materialization;
271 this means that we want to keep the body even if the origin is unreachable
272 otherwise. To avoid origin from sitting in the callgraph and being
273 walked by IPA passes, we turn them into unanalyzed nodes with body
276 We maintain set of function declaration where body needs to stay in
277 body_needed_for_clonning
279 Inline clones represent special case: their declaration match the
280 declaration of origin and cgraph_remove_node already knows how to
281 reshape callgraph and preserve body when offline copy of function or
282 inline clone is being removed.
284 - C++ virtual tables keyed to other unit are represented as DECL_EXTERNAL
285 variables with DECL_INITIAL set. We finalize these and keep reachable
286 ones around for constant folding purposes. After inlining we however
287 stop walking their references to let everything static referneced by them
288 to be removed when it is otherwise unreachable.
290 We maintain queue of both reachable symbols (i.e. defined symbols that needs
291 to stay) and symbols that are in boundary (i.e. external symbols referenced
292 by reachable symbols or origins of clones). The queue is represented
293 as linked list by AUX pointer terminated by 1.
295 At the end we keep all reachable symbols. For symbols in boundary we always
296 turn definition into a declaration, but we may keep function body around
297 based on body_needed_for_clonning
299 All symbols that enter the queue have AUX pointer non-zero and are in the
300 boundary. Pointer set REACHABLE is used to track reachable symbols.
302 Every symbol can be visited twice - once as part of boundary and once
303 as real reachable symbol. enqueue_node needs to decide whether the
304 node needs to be re-queued for second processing. For this purpose
305 we set AUX pointer of processed symbols in the boundary to constant 2. */
308 symbol_table::remove_unreachable_nodes (FILE *file
)
310 symtab_node
*first
= (symtab_node
*) (void *) 1;
311 struct cgraph_node
*node
, *next
;
312 varpool_node
*vnode
, *vnext
;
313 bool changed
= false;
314 hash_set
<symtab_node
*> reachable
;
315 hash_set
<tree
> body_needed_for_clonning
;
316 hash_set
<void *> reachable_call_targets
;
318 timevar_push (TV_IPA_UNREACHABLE
);
319 build_type_inheritance_graph ();
321 fprintf (file
, "\nReclaiming functions:");
324 FOR_EACH_FUNCTION (node
)
325 gcc_assert (!node
->aux
);
326 FOR_EACH_VARIABLE (vnode
)
327 gcc_assert (!vnode
->aux
);
329 /* Mark functions whose bodies are obviously needed.
330 This is mostly when they can be referenced externally. Inline clones
331 are special since their declarations are shared with master clone and thus
332 cgraph_can_remove_if_no_direct_calls_and_refs_p should not be called on them. */
333 FOR_EACH_FUNCTION (node
)
335 node
->used_as_abstract_origin
= false;
336 node
->indirect_call_target
= false;
338 && !node
->global
.inlined_to
339 && !node
->in_other_partition
340 && !node
->can_remove_if_no_direct_calls_and_refs_p ())
342 gcc_assert (!node
->global
.inlined_to
);
343 reachable
.add (node
);
344 enqueue_node (node
, &first
, &reachable
);
347 gcc_assert (!node
->aux
);
350 /* Mark variables that are obviously needed. */
351 FOR_EACH_DEFINED_VARIABLE (vnode
)
352 if (!vnode
->can_remove_if_no_refs_p()
353 && !vnode
->in_other_partition
)
355 reachable
.add (vnode
);
356 enqueue_node (vnode
, &first
, &reachable
);
359 /* Perform reachability analysis. */
360 while (first
!= (symtab_node
*) (void *) 1)
362 bool in_boundary_p
= !reachable
.contains (first
);
363 symtab_node
*node
= first
;
365 first
= (symtab_node
*)first
->aux
;
367 /* If we are processing symbol in boundary, mark its AUX pointer for
368 possible later re-processing in enqueue_node. */
371 node
->aux
= (void *)2;
372 if (node
->alias
&& node
->analyzed
)
373 enqueue_node (node
->get_alias_target (), &first
, &reachable
);
377 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
378 && DECL_ABSTRACT_ORIGIN (node
->decl
))
380 struct cgraph_node
*origin_node
381 = cgraph_node::get (DECL_ABSTRACT_ORIGIN (node
->decl
));
382 if (origin_node
&& !origin_node
->used_as_abstract_origin
)
384 origin_node
->used_as_abstract_origin
= true;
385 gcc_assert (!origin_node
->prev_sibling_clone
);
386 gcc_assert (!origin_node
->next_sibling_clone
);
387 for (cgraph_node
*n
= origin_node
->clones
; n
;
388 n
= n
->next_sibling_clone
)
389 if (n
->decl
== DECL_ABSTRACT_ORIGIN (node
->decl
))
390 n
->used_as_abstract_origin
= true;
393 /* If any symbol in a comdat group is reachable, force
394 all externally visible symbols in the same comdat
395 group to be reachable as well. Comdat-local symbols
396 can be discarded if all uses were inlined. */
397 if (node
->same_comdat_group
)
400 for (next
= node
->same_comdat_group
;
402 next
= next
->same_comdat_group
)
403 if (!next
->comdat_local_p ()
404 && !reachable
.add (next
))
405 enqueue_node (next
, &first
, &reachable
);
407 /* Mark references as reachable. */
408 process_references (node
, &first
, &reachable
);
411 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
))
413 /* Mark the callees reachable unless they are direct calls to extern
414 inline functions we decided to not inline. */
417 struct cgraph_edge
*e
;
418 /* Keep alive possible targets for devirtualization. */
419 if (opt_for_fn (cnode
->decl
, optimize
)
420 && opt_for_fn (cnode
->decl
, flag_devirtualize
))
422 struct cgraph_edge
*next
;
423 for (e
= cnode
->indirect_calls
; e
; e
= next
)
425 next
= e
->next_callee
;
426 if (e
->indirect_info
->polymorphic
)
427 walk_polymorphic_call_targets (&reachable_call_targets
,
428 e
, &first
, &reachable
);
431 for (e
= cnode
->callees
; e
; e
= e
->next_callee
)
433 symtab_node
*body
= e
->callee
->function_symbol ();
434 if (e
->callee
->definition
435 && !e
->callee
->in_other_partition
436 && (!e
->inline_failed
437 || !DECL_EXTERNAL (e
->callee
->decl
)
439 || possible_inline_candidate_p (e
->callee
)))
441 /* Be sure that we will not optimize out alias target
443 if (DECL_EXTERNAL (e
->callee
->decl
)
445 && symtab
->state
< IPA_SSA_AFTER_INLINING
)
446 reachable
.add (body
);
447 reachable
.add (e
->callee
);
449 enqueue_node (e
->callee
, &first
, &reachable
);
452 /* When inline clone exists, mark body to be preserved so when removing
453 offline copy of the function we don't kill it. */
454 if (cnode
->global
.inlined_to
)
455 body_needed_for_clonning
.add (cnode
->decl
);
457 /* For non-inline clones, force their origins to the boundary and ensure
458 that body is not removed. */
459 while (cnode
->clone_of
)
461 bool noninline
= cnode
->clone_of
->decl
!= cnode
->decl
;
462 cnode
= cnode
->clone_of
;
465 body_needed_for_clonning
.add (cnode
->decl
);
466 enqueue_node (cnode
, &first
, &reachable
);
471 else if (cnode
->thunk
.thunk_p
)
472 enqueue_node (cnode
->callees
->callee
, &first
, &reachable
);
474 /* If any reachable function has simd clones, mark them as
475 reachable as well. */
476 if (cnode
->simd_clones
)
479 for (next
= cnode
->simd_clones
;
481 next
= next
->simdclone
->next_clone
)
483 || !reachable
.add (next
))
484 enqueue_node (next
, &first
, &reachable
);
487 /* When we see constructor of external variable, keep referred nodes in the
488 boundary. This will also hold initializers of the external vars NODE
490 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
492 && DECL_EXTERNAL (node
->decl
)
496 struct ipa_ref
*ref
= NULL
;
497 for (int i
= 0; node
->iterate_reference (i
, ref
); i
++)
498 enqueue_node (ref
->referred
, &first
, &reachable
);
502 /* Remove unreachable functions. */
503 for (node
= first_function (); node
; node
= next
)
505 next
= next_function (node
);
507 /* If node is not needed at all, remove it. */
511 fprintf (file
, " %s", node
->dump_name ());
515 /* If node is unreachable, remove its body. */
516 else if (!reachable
.contains (node
))
518 /* We keep definitions of thunks and aliases in the boundary so
519 we can walk to the ultimate alias targets and function symbols
521 if (node
->alias
|| node
->thunk
.thunk_p
)
523 else if (!body_needed_for_clonning
.contains (node
->decl
)
524 && !node
->alias
&& !node
->thunk
.thunk_p
)
525 node
->release_body ();
526 else if (!node
->clone_of
)
527 gcc_assert (in_lto_p
|| DECL_RESULT (node
->decl
));
528 if (node
->definition
&& !node
->alias
&& !node
->thunk
.thunk_p
)
531 fprintf (file
, " %s", node
->dump_name ());
532 node
->body_removed
= true;
533 node
->analyzed
= false;
534 node
->definition
= false;
535 node
->cpp_implicit_alias
= false;
537 node
->transparent_alias
= false;
538 node
->thunk
.thunk_p
= false;
539 node
->weakref
= false;
540 /* After early inlining we drop always_inline attributes on
541 bodies of functions that are still referenced (have their
543 DECL_ATTRIBUTES (node
->decl
)
544 = remove_attribute ("always_inline",
545 DECL_ATTRIBUTES (node
->decl
));
546 if (!node
->in_other_partition
)
547 node
->local
.local
= false;
548 node
->remove_callees ();
549 node
->remove_all_references ();
551 if (node
->thunk
.thunk_p
552 && node
->thunk
.add_pointer_bounds_args
)
554 node
->thunk
.thunk_p
= false;
555 node
->thunk
.add_pointer_bounds_args
= false;
560 gcc_assert (node
->clone_of
|| !node
->has_gimple_body_p ()
561 || in_lto_p
|| DECL_RESULT (node
->decl
));
564 /* Inline clones might be kept around so their materializing allows further
565 cloning. If the function the clone is inlined into is removed, we need
566 to turn it into normal cone. */
567 FOR_EACH_FUNCTION (node
)
569 if (node
->global
.inlined_to
572 gcc_assert (node
->clones
);
573 node
->global
.inlined_to
= NULL
;
574 update_inlined_to_pointer (node
, node
);
579 /* Remove unreachable variables. */
581 fprintf (file
, "\nReclaiming variables:");
582 for (vnode
= first_variable (); vnode
; vnode
= vnext
)
584 vnext
= next_variable (vnode
);
586 /* For can_refer_decl_in_current_unit_p we want to track for
587 all external variables if they are defined in other partition
589 && (!flag_ltrans
|| !DECL_EXTERNAL (vnode
->decl
)))
591 struct ipa_ref
*ref
= NULL
;
593 /* First remove the aliases, so varpool::remove can possibly lookup
594 the constructor and save it for future use. */
595 while (vnode
->iterate_direct_aliases (0, ref
))
598 fprintf (file
, " %s", ref
->referred
->dump_name ());
599 ref
->referring
->remove ();
602 fprintf (file
, " %s", vnode
->dump_name ());
603 vnext
= next_variable (vnode
);
604 /* Signal removal to the debug machinery. */
605 if (! flag_wpa
|| flag_incremental_link
== INCREMENTAL_LINK_LTO
)
607 vnode
->definition
= false;
608 (*debug_hooks
->late_global_decl
) (vnode
->decl
);
613 else if (!reachable
.contains (vnode
) && !vnode
->alias
)
616 if (vnode
->definition
)
619 fprintf (file
, " %s", vnode
->name ());
622 /* Keep body if it may be useful for constant folding. */
623 if ((flag_wpa
|| flag_incremental_link
== INCREMENTAL_LINK_LTO
)
624 || ((init
= ctor_for_folding (vnode
->decl
)) == error_mark_node
))
625 vnode
->remove_initializer ();
627 DECL_INITIAL (vnode
->decl
) = init
;
628 vnode
->body_removed
= true;
629 vnode
->definition
= false;
630 vnode
->analyzed
= false;
633 vnode
->remove_from_same_comdat_group ();
635 vnode
->remove_all_references ();
641 /* Now update address_taken flags and try to promote functions to be local. */
643 fprintf (file
, "\nClearing address taken flags:");
644 FOR_EACH_DEFINED_FUNCTION (node
)
645 if (node
->address_taken
646 && !node
->used_from_other_partition
)
648 if (!node
->call_for_symbol_and_aliases
649 (has_addr_references_p
, NULL
, true))
652 fprintf (file
, " %s", node
->name ());
653 node
->address_taken
= false;
656 /* Virtual functions may be kept in cgraph just because
657 of possible later devirtualization. Do not mark them as
658 local too early so we won't optimize them out before
659 we are done with polymorphic call analysis. */
660 && (symtab
->state
>= IPA_SSA_AFTER_INLINING
661 || !node
->call_for_symbol_and_aliases
662 (is_indirect_call_target_p
, NULL
, true)))
664 node
->local
.local
= true;
666 fprintf (file
, " (local)");
671 fprintf (file
, "\n");
673 symtab_node::checking_verify_symtab_nodes ();
675 /* If we removed something, perhaps profile could be improved. */
676 if (changed
&& (optimize
|| in_lto_p
) && ipa_call_summaries
)
677 FOR_EACH_DEFINED_FUNCTION (node
)
678 ipa_propagate_frequency (node
);
680 timevar_pop (TV_IPA_UNREACHABLE
);
684 /* Process references to VNODE and set flags WRITTEN, ADDRESS_TAKEN, READ
685 as needed, also clear EXPLICIT_REFS if the references to given variable
686 do not need to be explicit. */
689 process_references (varpool_node
*vnode
,
690 bool *written
, bool *address_taken
,
691 bool *read
, bool *explicit_refs
)
696 if (!vnode
->all_refs_explicit_p ()
697 || TREE_THIS_VOLATILE (vnode
->decl
))
698 *explicit_refs
= false;
700 for (i
= 0; vnode
->iterate_referring (i
, ref
)
701 && *explicit_refs
&& (!*written
|| !*address_taken
|| !*read
); i
++)
705 *address_taken
= true;
714 process_references (dyn_cast
<varpool_node
*> (ref
->referring
), written
,
715 address_taken
, read
, explicit_refs
);
720 /* Set TREE_READONLY bit. */
723 set_readonly_bit (varpool_node
*vnode
, void *data ATTRIBUTE_UNUSED
)
725 TREE_READONLY (vnode
->decl
) = true;
729 /* Set writeonly bit and clear the initalizer, since it will not be needed. */
732 set_writeonly_bit (varpool_node
*vnode
, void *data
)
734 vnode
->writeonly
= true;
735 if (optimize
|| in_lto_p
)
737 DECL_INITIAL (vnode
->decl
) = NULL
;
740 if (vnode
->num_references ())
741 *(bool *)data
= true;
742 vnode
->remove_all_references ();
748 /* Clear addressale bit of VNODE. */
751 clear_addressable_bit (varpool_node
*vnode
, void *data ATTRIBUTE_UNUSED
)
753 vnode
->address_taken
= false;
754 TREE_ADDRESSABLE (vnode
->decl
) = 0;
758 /* Discover variables that have no longer address taken, are read-only or
759 write-only and update their flags.
761 Return true when unreachable symbol removal should be done.
763 FIXME: This cannot be done in between gimplify and omp_expand since
764 readonly flag plays role on what is shared and what is not. Currently we do
765 this transformation as part of whole program visibility and re-do at
766 ipa-reference pass (to take into account clonning), but it would
767 make sense to do it before early optimizations. */
770 ipa_discover_variable_flags (void)
772 if (!flag_ipa_reference_addressable
)
775 bool remove_p
= false;
778 fprintf (dump_file
, "Clearing variable flags:");
779 FOR_EACH_VARIABLE (vnode
)
781 && (TREE_ADDRESSABLE (vnode
->decl
)
783 || !TREE_READONLY (vnode
->decl
)))
785 bool written
= false;
786 bool address_taken
= false;
788 bool explicit_refs
= true;
790 process_references (vnode
, &written
, &address_taken
, &read
,
796 if (TREE_ADDRESSABLE (vnode
->decl
) && dump_file
)
797 fprintf (dump_file
, " %s (non-addressable)", vnode
->name ());
798 vnode
->call_for_symbol_and_aliases (clear_addressable_bit
, NULL
,
801 if (!address_taken
&& !written
802 /* Making variable in explicit section readonly can cause section
804 See e.g. gcc.c-torture/compile/pr23237.c */
805 && vnode
->get_section () == NULL
)
807 if (!TREE_READONLY (vnode
->decl
) && dump_file
)
808 fprintf (dump_file
, " %s (read-only)", vnode
->name ());
809 vnode
->call_for_symbol_and_aliases (set_readonly_bit
, NULL
, true);
811 if (!vnode
->writeonly
&& !read
&& !address_taken
&& written
)
814 fprintf (dump_file
, " %s (write-only)", vnode
->name ());
815 vnode
->call_for_symbol_and_aliases (set_writeonly_bit
, &remove_p
,
820 fprintf (dump_file
, "\n");
824 /* Generate and emit a static constructor or destructor. WHICH must
825 be one of 'I' (for a constructor), 'D' (for a destructor).
826 BODY is a STATEMENT_LIST containing GENERIC
827 statements. PRIORITY is the initialization priority for this
828 constructor or destructor.
830 FINAL specify whether the externally visible name for collect2 should
834 cgraph_build_static_cdtor_1 (char which
, tree body
, int priority
, bool final
,
838 static int counter
= 0;
840 tree decl
, name
, resdecl
;
842 /* The priority is encoded in the constructor or destructor name.
843 collect2 will sort the names and arrange that they are called at
846 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
848 /* Proudce sane name but one not recognizable by collect2, just for the
849 case we fail to inline the function. */
850 sprintf (which_buf
, "sub_%c_%.5d_%d", which
, priority
, counter
++);
851 name
= get_file_function_name (which_buf
);
853 decl
= build_decl (input_location
, FUNCTION_DECL
, name
,
854 build_function_type_list (void_type_node
, NULL_TREE
));
855 current_function_decl
= decl
;
857 resdecl
= build_decl (input_location
,
858 RESULT_DECL
, NULL_TREE
, void_type_node
);
859 DECL_ARTIFICIAL (resdecl
) = 1;
860 DECL_RESULT (decl
) = resdecl
;
861 DECL_CONTEXT (resdecl
) = decl
;
863 allocate_struct_function (decl
, false);
865 TREE_STATIC (decl
) = 1;
866 TREE_USED (decl
) = 1;
867 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl
) = optimization
;
868 DECL_FUNCTION_SPECIFIC_TARGET (decl
) = target
;
869 DECL_ARTIFICIAL (decl
) = 1;
870 DECL_IGNORED_P (decl
) = 1;
871 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
872 DECL_SAVED_TREE (decl
) = body
;
873 if (!targetm
.have_ctors_dtors
&& final
)
875 TREE_PUBLIC (decl
) = 1;
876 DECL_PRESERVE_P (decl
) = 1;
878 DECL_UNINLINABLE (decl
) = 1;
880 DECL_INITIAL (decl
) = make_node (BLOCK
);
881 BLOCK_SUPERCONTEXT (DECL_INITIAL (decl
)) = decl
;
882 TREE_USED (DECL_INITIAL (decl
)) = 1;
884 DECL_SOURCE_LOCATION (decl
) = input_location
;
885 cfun
->function_end_locus
= input_location
;
890 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
891 decl_init_priority_insert (decl
, priority
);
894 DECL_STATIC_DESTRUCTOR (decl
) = 1;
895 decl_fini_priority_insert (decl
, priority
);
901 gimplify_function_tree (decl
);
903 cgraph_node::add_new_function (decl
, false);
906 current_function_decl
= NULL
;
909 /* Generate and emit a static constructor or destructor. WHICH must
910 be one of 'I' (for a constructor) or 'D' (for a destructor).
911 BODY is a STATEMENT_LIST containing GENERIC
912 statements. PRIORITY is the initialization priority for this
913 constructor or destructor. */
916 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
918 cgraph_build_static_cdtor_1 (which
, body
, priority
, false, NULL
, NULL
);
921 /* When target does not have ctors and dtors, we call all constructor
922 and destructor by special initialization/destruction function
923 recognized by collect2.
925 When we are going to build this function, collect all constructors and
926 destructors and turn them into normal functions. */
929 record_cdtor_fn (struct cgraph_node
*node
, vec
<tree
> *ctors
, vec
<tree
> *dtors
)
931 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
932 ctors
->safe_push (node
->decl
);
933 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
934 dtors
->safe_push (node
->decl
);
935 node
= cgraph_node::get (node
->decl
);
936 DECL_DISREGARD_INLINE_LIMITS (node
->decl
) = 1;
939 /* Define global constructors/destructor functions for the CDTORS, of
940 which they are LEN. The CDTORS are sorted by initialization
941 priority. If CTOR_P is true, these are constructors; otherwise,
942 they are destructors. */
945 build_cdtor (bool ctor_p
, const vec
<tree
> &cdtors
)
948 size_t len
= cdtors
.length ();
955 priority_type priority
;
964 p
= ctor_p
? DECL_INIT_PRIORITY (fn
) : DECL_FINI_PRIORITY (fn
);
967 else if (p
!= priority
)
973 /* When there is only one cdtor and target supports them, do nothing. */
975 && targetm
.have_ctors_dtors
)
980 /* Find the next batch of constructors/destructors with the same
981 initialization priority. */
986 call
= build_call_expr (fn
, 0);
988 DECL_STATIC_CONSTRUCTOR (fn
) = 0;
990 DECL_STATIC_DESTRUCTOR (fn
) = 0;
991 /* We do not want to optimize away pure/const calls here.
992 When optimizing, these should be already removed, when not
993 optimizing, we want user to be able to breakpoint in them. */
994 TREE_SIDE_EFFECTS (call
) = 1;
995 append_to_statement_list (call
, &body
);
997 gcc_assert (body
!= NULL_TREE
);
998 /* Generate a function to call all the function of like
1000 cgraph_build_static_cdtor_1 (ctor_p
? 'I' : 'D', body
, priority
, true,
1001 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (cdtors
[0]),
1002 DECL_FUNCTION_SPECIFIC_TARGET (cdtors
[0]));
1006 /* Comparison function for qsort. P1 and P2 are actually of type
1007 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
1008 used to determine the sort order. */
1011 compare_ctor (const void *p1
, const void *p2
)
1018 f1
= *(const tree
*)p1
;
1019 f2
= *(const tree
*)p2
;
1020 priority1
= DECL_INIT_PRIORITY (f1
);
1021 priority2
= DECL_INIT_PRIORITY (f2
);
1023 if (priority1
< priority2
)
1025 else if (priority1
> priority2
)
1028 /* Ensure a stable sort. Constructors are executed in backwarding
1029 order to make LTO initialize braries first. */
1030 return DECL_UID (f2
) - DECL_UID (f1
);
1033 /* Comparison function for qsort. P1 and P2 are actually of type
1034 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
1035 used to determine the sort order. */
1038 compare_dtor (const void *p1
, const void *p2
)
1045 f1
= *(const tree
*)p1
;
1046 f2
= *(const tree
*)p2
;
1047 priority1
= DECL_FINI_PRIORITY (f1
);
1048 priority2
= DECL_FINI_PRIORITY (f2
);
1050 if (priority1
< priority2
)
1052 else if (priority1
> priority2
)
1055 /* Ensure a stable sort. */
1056 return DECL_UID (f1
) - DECL_UID (f2
);
1059 /* Generate functions to call static constructors and destructors
1060 for targets that do not support .ctors/.dtors sections. These
1061 functions have magic names which are detected by collect2. */
1064 build_cdtor_fns (vec
<tree
> *ctors
, vec
<tree
> *dtors
)
1066 if (!ctors
->is_empty ())
1068 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1069 ctors
->qsort (compare_ctor
);
1070 build_cdtor (/*ctor_p=*/true, *ctors
);
1073 if (!dtors
->is_empty ())
1075 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1076 dtors
->qsort (compare_dtor
);
1077 build_cdtor (/*ctor_p=*/false, *dtors
);
1081 /* Look for constructors and destructors and produce function calling them.
1082 This is needed for targets not supporting ctors or dtors, but we perform the
1083 transformation also at linktime to merge possibly numerous
1084 constructors/destructors into single function to improve code locality and
1088 ipa_cdtor_merge (void)
1090 /* A vector of FUNCTION_DECLs declared as static constructors. */
1091 auto_vec
<tree
, 20> ctors
;
1092 /* A vector of FUNCTION_DECLs declared as static destructors. */
1093 auto_vec
<tree
, 20> dtors
;
1094 struct cgraph_node
*node
;
1095 FOR_EACH_DEFINED_FUNCTION (node
)
1096 if (DECL_STATIC_CONSTRUCTOR (node
->decl
)
1097 || DECL_STATIC_DESTRUCTOR (node
->decl
))
1098 record_cdtor_fn (node
, &ctors
, &dtors
);
1099 build_cdtor_fns (&ctors
, &dtors
);
1105 const pass_data pass_data_ipa_cdtor_merge
=
1107 IPA_PASS
, /* type */
1109 OPTGROUP_NONE
, /* optinfo_flags */
1110 TV_CGRAPHOPT
, /* tv_id */
1111 0, /* properties_required */
1112 0, /* properties_provided */
1113 0, /* properties_destroyed */
1114 0, /* todo_flags_start */
1115 0, /* todo_flags_finish */
1118 class pass_ipa_cdtor_merge
: public ipa_opt_pass_d
1121 pass_ipa_cdtor_merge (gcc::context
*ctxt
)
1122 : ipa_opt_pass_d (pass_data_ipa_cdtor_merge
, ctxt
,
1123 NULL
, /* generate_summary */
1124 NULL
, /* write_summary */
1125 NULL
, /* read_summary */
1126 NULL
, /* write_optimization_summary */
1127 NULL
, /* read_optimization_summary */
1128 NULL
, /* stmt_fixup */
1129 0, /* function_transform_todo_flags_start */
1130 NULL
, /* function_transform */
1131 NULL
) /* variable_transform */
1134 /* opt_pass methods: */
1135 virtual bool gate (function
*);
1136 virtual unsigned int execute (function
*) { return ipa_cdtor_merge (); }
1138 }; // class pass_ipa_cdtor_merge
1141 pass_ipa_cdtor_merge::gate (function
*)
1143 /* Perform the pass when we have no ctors/dtors support
1144 or at LTO time to merge multiple constructors into single
1146 return !targetm
.have_ctors_dtors
|| in_lto_p
;
1152 make_pass_ipa_cdtor_merge (gcc::context
*ctxt
)
1154 return new pass_ipa_cdtor_merge (ctxt
);
1157 /* Invalid pointer representing BOTTOM for single user dataflow. */
1158 #define BOTTOM ((cgraph_node *)(size_t) 2)
1160 /* Meet operation for single user dataflow.
1161 Here we want to associate variables with sigle function that may access it.
1163 FUNCTION is current single user of a variable, VAR is variable that uses it.
1164 Latttice is stored in SINGLE_USER_MAP.
1167 - TOP by no entry in SIGNLE_USER_MAP
1168 - BOTTOM by BOTTOM in AUX pointer (to save lookups)
1169 - known single user by cgraph pointer in SINGLE_USER_MAP. */
1172 meet (cgraph_node
*function
, varpool_node
*var
,
1173 hash_map
<varpool_node
*, cgraph_node
*> &single_user_map
)
1175 struct cgraph_node
*user
, **f
;
1177 if (var
->aux
== BOTTOM
)
1180 f
= single_user_map
.get (var
);
1186 else if (function
!= user
)
1192 /* Propagation step of single-use dataflow.
1194 Check all uses of VNODE and see if they are used by single function FUNCTION.
1195 SINGLE_USER_MAP represents the dataflow lattice. */
1198 propagate_single_user (varpool_node
*vnode
, cgraph_node
*function
,
1199 hash_map
<varpool_node
*, cgraph_node
*> &single_user_map
)
1202 struct ipa_ref
*ref
;
1204 gcc_assert (!vnode
->externally_visible
);
1206 /* If node is an alias, first meet with its target. */
1208 function
= meet (function
, vnode
->get_alias_target (), single_user_map
);
1210 /* Check all users and see if they correspond to a single function. */
1211 for (i
= 0; vnode
->iterate_referring (i
, ref
) && function
!= BOTTOM
; i
++)
1213 struct cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (ref
->referring
);
1216 if (cnode
->global
.inlined_to
)
1217 cnode
= cnode
->global
.inlined_to
;
1220 else if (function
!= cnode
)
1224 function
= meet (function
, dyn_cast
<varpool_node
*> (ref
->referring
),
1230 /* Pass setting used_by_single_function flag.
1231 This flag is set on variable when there is only one function that may
1232 possibly referr to it. */
1235 ipa_single_use (void)
1237 varpool_node
*first
= (varpool_node
*) (void *) 1;
1239 hash_map
<varpool_node
*, cgraph_node
*> single_user_map
;
1241 FOR_EACH_DEFINED_VARIABLE (var
)
1242 if (!var
->all_refs_explicit_p ())
1246 /* Enqueue symbol for dataflow. */
1251 /* The actual dataflow. */
1253 while (first
!= (void *) 1)
1255 cgraph_node
*user
, *orig_user
, **f
;
1258 first
= (varpool_node
*)first
->aux
;
1260 f
= single_user_map
.get (var
);
1265 user
= propagate_single_user (var
, orig_user
, single_user_map
);
1267 gcc_checking_assert (var
->aux
!= BOTTOM
);
1269 /* If user differs, enqueue all references. */
1270 if (user
!= orig_user
)
1275 single_user_map
.put (var
, user
);
1277 /* Enqueue all aliases for re-processing. */
1278 for (i
= 0; var
->iterate_direct_aliases (i
, ref
); i
++)
1279 if (!ref
->referring
->aux
)
1281 ref
->referring
->aux
= first
;
1282 first
= dyn_cast
<varpool_node
*> (ref
->referring
);
1284 /* Enqueue all users for re-processing. */
1285 for (i
= 0; var
->iterate_reference (i
, ref
); i
++)
1286 if (!ref
->referred
->aux
1287 && ref
->referred
->definition
1288 && is_a
<varpool_node
*> (ref
->referred
))
1290 ref
->referred
->aux
= first
;
1291 first
= dyn_cast
<varpool_node
*> (ref
->referred
);
1294 /* If user is BOTTOM, just punt on this var. */
1304 FOR_EACH_DEFINED_VARIABLE (var
)
1306 if (var
->aux
!= BOTTOM
)
1308 /* Not having the single user known means that the VAR is
1309 unreachable. Either someone forgot to remove unreachable
1310 variables or the reachability here is wrong. */
1312 gcc_checking_assert (single_user_map
.get (var
));
1316 fprintf (dump_file
, "Variable %s is used by single function\n",
1319 var
->used_by_single_function
= true;
1328 const pass_data pass_data_ipa_single_use
=
1330 IPA_PASS
, /* type */
1331 "single-use", /* name */
1332 OPTGROUP_NONE
, /* optinfo_flags */
1333 TV_CGRAPHOPT
, /* tv_id */
1334 0, /* properties_required */
1335 0, /* properties_provided */
1336 0, /* properties_destroyed */
1337 0, /* todo_flags_start */
1338 0, /* todo_flags_finish */
1341 class pass_ipa_single_use
: public ipa_opt_pass_d
1344 pass_ipa_single_use (gcc::context
*ctxt
)
1345 : ipa_opt_pass_d (pass_data_ipa_single_use
, ctxt
,
1346 NULL
, /* generate_summary */
1347 NULL
, /* write_summary */
1348 NULL
, /* read_summary */
1349 NULL
, /* write_optimization_summary */
1350 NULL
, /* read_optimization_summary */
1351 NULL
, /* stmt_fixup */
1352 0, /* function_transform_todo_flags_start */
1353 NULL
, /* function_transform */
1354 NULL
) /* variable_transform */
1357 /* opt_pass methods: */
1358 virtual unsigned int execute (function
*) { return ipa_single_use (); }
1360 }; // class pass_ipa_single_use
1365 make_pass_ipa_single_use (gcc::context
*ctxt
)
1367 return new pass_ipa_single_use (ctxt
);
1370 /* Materialize all clones. */
1374 const pass_data pass_data_materialize_all_clones
=
1376 SIMPLE_IPA_PASS
, /* type */
1377 "materialize-all-clones", /* name */
1378 OPTGROUP_NONE
, /* optinfo_flags */
1379 TV_IPA_OPT
, /* tv_id */
1380 0, /* properties_required */
1381 0, /* properties_provided */
1382 0, /* properties_destroyed */
1383 0, /* todo_flags_start */
1384 0, /* todo_flags_finish */
1387 class pass_materialize_all_clones
: public simple_ipa_opt_pass
1390 pass_materialize_all_clones (gcc::context
*ctxt
)
1391 : simple_ipa_opt_pass (pass_data_materialize_all_clones
, ctxt
)
1394 /* opt_pass methods: */
1395 virtual unsigned int execute (function
*)
1397 symtab
->materialize_all_clones ();
1401 }; // class pass_materialize_all_clones
1405 simple_ipa_opt_pass
*
1406 make_pass_materialize_all_clones (gcc::context
*ctxt
)
1408 return new pass_materialize_all_clones (ctxt
);