1 /* Basic IPA optimizations and utilities.
2 Copyright (C) 2003-2018 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 /* Process references. */
107 process_references (symtab_node
*snode
,
109 bool before_inlining_p
,
110 hash_set
<symtab_node
*> *reachable
)
113 struct ipa_ref
*ref
= NULL
;
114 for (i
= 0; snode
->iterate_reference (i
, ref
); i
++)
116 symtab_node
*node
= ref
->referred
;
117 symtab_node
*body
= node
->ultimate_alias_target ();
119 if (node
->definition
&& !node
->in_other_partition
120 && ((!DECL_EXTERNAL (node
->decl
) || node
->alias
)
121 || (((before_inlining_p
122 && (TREE_CODE (node
->decl
) != FUNCTION_DECL
123 || (TREE_CODE (node
->decl
) == FUNCTION_DECL
124 && opt_for_fn (body
->decl
, optimize
))
125 || (symtab
->state
< IPA_SSA
128 DECL_ATTRIBUTES (body
->decl
))))))
129 /* We use variable constructors during late compilation for
130 constant folding. Keep references alive so partitioning
131 knows about potential references. */
132 || (VAR_P (node
->decl
)
134 || flag_incremental_link
135 == INCREMENTAL_LINK_LTO
)
136 && dyn_cast
<varpool_node
*> (node
)
137 ->ctor_useable_for_folding_p ()))))
139 /* Be sure that we will not optimize out alias target
141 if (DECL_EXTERNAL (node
->decl
)
143 && before_inlining_p
)
144 reachable
->add (body
);
145 reachable
->add (node
);
147 enqueue_node (node
, first
, reachable
);
151 /* EDGE is an polymorphic call. If BEFORE_INLINING_P is set, mark
152 all its potential targets as reachable to permit later inlining if
153 devirtualization happens. After inlining still keep their declarations
154 around, so we can devirtualize to a direct call.
156 Also try to make trivial devirutalization when no or only one target is
160 walk_polymorphic_call_targets (hash_set
<void *> *reachable_call_targets
,
161 struct cgraph_edge
*edge
,
163 hash_set
<symtab_node
*> *reachable
,
164 bool before_inlining_p
)
169 vec
<cgraph_node
*>targets
170 = possible_polymorphic_call_targets
171 (edge
, &final
, &cache_token
);
173 if (!reachable_call_targets
->add (cache_token
))
175 for (i
= 0; i
< targets
.length (); i
++)
177 struct cgraph_node
*n
= targets
[i
];
179 /* Do not bother to mark virtual methods in anonymous namespace;
180 either we will find use of virtual table defining it, or it is
182 if (TREE_CODE (TREE_TYPE (n
->decl
)) == METHOD_TYPE
183 && type_in_anonymous_namespace_p
184 (TYPE_METHOD_BASETYPE (TREE_TYPE (n
->decl
))))
187 n
->indirect_call_target
= true;
188 symtab_node
*body
= n
->function_symbol ();
190 /* Prior inlining, keep alive bodies of possible targets for
193 && (before_inlining_p
194 && opt_for_fn (body
->decl
, optimize
)
195 && opt_for_fn (body
->decl
, flag_devirtualize
)))
197 /* Be sure that we will not optimize out alias target
199 if (DECL_EXTERNAL (n
->decl
)
201 && before_inlining_p
)
202 reachable
->add (body
);
205 /* Even after inlining we want to keep the possible targets in the
206 boundary, so late passes can still produce direct call even if
207 the chance for inlining is lost. */
208 enqueue_node (n
, first
, reachable
);
212 /* Very trivial devirtualization; when the type is
213 final or anonymous (so we know all its derivation)
214 and there is only one possible virtual call target,
215 make the edge direct. */
218 if (targets
.length () <= 1 && dbg_cnt (devirt
))
220 cgraph_node
*target
, *node
= edge
->caller
;
221 if (targets
.length () == 1)
224 target
= cgraph_node::get_create
225 (builtin_decl_implicit (BUILT_IN_UNREACHABLE
));
227 if (dump_enabled_p ())
229 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, edge
->call_stmt
,
230 "devirtualizing call in %s to %s\n",
231 edge
->caller
->dump_name (),
232 target
->dump_name ());
234 edge
= edge
->make_direct (target
);
235 if (ipa_fn_summaries
)
236 ipa_update_overall_fn_summary (node
);
237 else if (edge
->call_stmt
)
238 edge
->redirect_call_stmt_to_callee ();
243 /* Perform reachability analysis and reclaim all unreachable nodes.
245 The algorithm is basically mark&sweep but with some extra refinements:
247 - reachable extern inline functions needs special handling; the bodies needs
248 to stay in memory until inlining in hope that they will be inlined.
249 After inlining we release their bodies and turn them into unanalyzed
250 nodes even when they are reachable.
252 - virtual functions are kept in callgraph even if they seem unreachable in
253 hope calls to them will be devirtualized.
255 Again we remove them after inlining. In late optimization some
256 devirtualization may happen, but it is not important since we won't inline
257 the call. In theory early opts and IPA should work out all important cases.
259 - virtual clones needs bodies of their origins for later materialization;
260 this means that we want to keep the body even if the origin is unreachable
261 otherwise. To avoid origin from sitting in the callgraph and being
262 walked by IPA passes, we turn them into unanalyzed nodes with body
265 We maintain set of function declaration where body needs to stay in
266 body_needed_for_clonning
268 Inline clones represent special case: their declaration match the
269 declaration of origin and cgraph_remove_node already knows how to
270 reshape callgraph and preserve body when offline copy of function or
271 inline clone is being removed.
273 - C++ virtual tables keyed to other unit are represented as DECL_EXTERNAL
274 variables with DECL_INITIAL set. We finalize these and keep reachable
275 ones around for constant folding purposes. After inlining we however
276 stop walking their references to let everything static referneced by them
277 to be removed when it is otherwise unreachable.
279 We maintain queue of both reachable symbols (i.e. defined symbols that needs
280 to stay) and symbols that are in boundary (i.e. external symbols referenced
281 by reachable symbols or origins of clones). The queue is represented
282 as linked list by AUX pointer terminated by 1.
284 At the end we keep all reachable symbols. For symbols in boundary we always
285 turn definition into a declaration, but we may keep function body around
286 based on body_needed_for_clonning
288 All symbols that enter the queue have AUX pointer non-zero and are in the
289 boundary. Pointer set REACHABLE is used to track reachable symbols.
291 Every symbol can be visited twice - once as part of boundary and once
292 as real reachable symbol. enqueue_node needs to decide whether the
293 node needs to be re-queued for second processing. For this purpose
294 we set AUX pointer of processed symbols in the boundary to constant 2. */
297 symbol_table::remove_unreachable_nodes (FILE *file
)
299 symtab_node
*first
= (symtab_node
*) (void *) 1;
300 struct cgraph_node
*node
, *next
;
301 varpool_node
*vnode
, *vnext
;
302 bool changed
= false;
303 hash_set
<symtab_node
*> reachable
;
304 hash_set
<tree
> body_needed_for_clonning
;
305 hash_set
<void *> reachable_call_targets
;
306 bool before_inlining_p
= symtab
->state
< (!optimize
&& !in_lto_p
? IPA_SSA
307 : IPA_SSA_AFTER_INLINING
);
309 timevar_push (TV_IPA_UNREACHABLE
);
310 build_type_inheritance_graph ();
312 fprintf (file
, "\nReclaiming functions:");
315 FOR_EACH_FUNCTION (node
)
316 gcc_assert (!node
->aux
);
317 FOR_EACH_VARIABLE (vnode
)
318 gcc_assert (!vnode
->aux
);
320 /* Mark functions whose bodies are obviously needed.
321 This is mostly when they can be referenced externally. Inline clones
322 are special since their declarations are shared with master clone and thus
323 cgraph_can_remove_if_no_direct_calls_and_refs_p should not be called on them. */
324 FOR_EACH_FUNCTION (node
)
326 node
->used_as_abstract_origin
= false;
327 node
->indirect_call_target
= false;
329 && !node
->global
.inlined_to
330 && !node
->in_other_partition
331 && !node
->can_remove_if_no_direct_calls_and_refs_p ())
333 gcc_assert (!node
->global
.inlined_to
);
334 reachable
.add (node
);
335 enqueue_node (node
, &first
, &reachable
);
338 gcc_assert (!node
->aux
);
341 /* Mark variables that are obviously needed. */
342 FOR_EACH_DEFINED_VARIABLE (vnode
)
343 if (!vnode
->can_remove_if_no_refs_p()
344 && !vnode
->in_other_partition
)
346 reachable
.add (vnode
);
347 enqueue_node (vnode
, &first
, &reachable
);
350 /* Perform reachability analysis. */
351 while (first
!= (symtab_node
*) (void *) 1)
353 bool in_boundary_p
= !reachable
.contains (first
);
354 symtab_node
*node
= first
;
356 first
= (symtab_node
*)first
->aux
;
358 /* If we are processing symbol in boundary, mark its AUX pointer for
359 possible later re-processing in enqueue_node. */
362 node
->aux
= (void *)2;
363 if (node
->alias
&& node
->analyzed
)
364 enqueue_node (node
->get_alias_target (), &first
, &reachable
);
368 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
369 && DECL_ABSTRACT_ORIGIN (node
->decl
))
371 struct cgraph_node
*origin_node
372 = cgraph_node::get (DECL_ABSTRACT_ORIGIN (node
->decl
));
373 if (origin_node
&& !origin_node
->used_as_abstract_origin
)
375 origin_node
->used_as_abstract_origin
= true;
376 gcc_assert (!origin_node
->prev_sibling_clone
);
377 gcc_assert (!origin_node
->next_sibling_clone
);
378 for (cgraph_node
*n
= origin_node
->clones
; n
;
379 n
= n
->next_sibling_clone
)
380 if (n
->decl
== DECL_ABSTRACT_ORIGIN (node
->decl
))
381 n
->used_as_abstract_origin
= true;
384 /* If any symbol in a comdat group is reachable, force
385 all externally visible symbols in the same comdat
386 group to be reachable as well. Comdat-local symbols
387 can be discarded if all uses were inlined. */
388 if (node
->same_comdat_group
)
391 for (next
= node
->same_comdat_group
;
393 next
= next
->same_comdat_group
)
394 if (!next
->comdat_local_p ()
395 && !reachable
.add (next
))
396 enqueue_node (next
, &first
, &reachable
);
398 /* Mark references as reachable. */
399 process_references (node
, &first
, before_inlining_p
, &reachable
);
402 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
))
404 /* Mark the callees reachable unless they are direct calls to extern
405 inline functions we decided to not inline. */
408 struct cgraph_edge
*e
;
409 /* Keep alive possible targets for devirtualization. */
410 if (opt_for_fn (cnode
->decl
, optimize
)
411 && opt_for_fn (cnode
->decl
, flag_devirtualize
))
413 struct cgraph_edge
*next
;
414 for (e
= cnode
->indirect_calls
; e
; e
= next
)
416 next
= e
->next_callee
;
417 if (e
->indirect_info
->polymorphic
)
418 walk_polymorphic_call_targets (&reachable_call_targets
,
419 e
, &first
, &reachable
,
423 for (e
= cnode
->callees
; e
; e
= e
->next_callee
)
425 symtab_node
*body
= e
->callee
->function_symbol ();
426 if (e
->callee
->definition
427 && !e
->callee
->in_other_partition
428 && (!e
->inline_failed
429 || !DECL_EXTERNAL (e
->callee
->decl
)
431 || (before_inlining_p
432 && (opt_for_fn (body
->decl
, optimize
)
433 || (symtab
->state
< IPA_SSA
436 DECL_ATTRIBUTES (body
->decl
)))))))
438 /* Be sure that we will not optimize out alias target
440 if (DECL_EXTERNAL (e
->callee
->decl
)
442 && before_inlining_p
)
443 reachable
.add (body
);
444 reachable
.add (e
->callee
);
446 enqueue_node (e
->callee
, &first
, &reachable
);
449 /* When inline clone exists, mark body to be preserved so when removing
450 offline copy of the function we don't kill it. */
451 if (cnode
->global
.inlined_to
)
452 body_needed_for_clonning
.add (cnode
->decl
);
454 /* For non-inline clones, force their origins to the boundary and ensure
455 that body is not removed. */
456 while (cnode
->clone_of
)
458 bool noninline
= cnode
->clone_of
->decl
!= cnode
->decl
;
459 cnode
= cnode
->clone_of
;
462 body_needed_for_clonning
.add (cnode
->decl
);
463 enqueue_node (cnode
, &first
, &reachable
);
468 else if (cnode
->thunk
.thunk_p
)
469 enqueue_node (cnode
->callees
->callee
, &first
, &reachable
);
471 /* If any reachable function has simd clones, mark them as
472 reachable as well. */
473 if (cnode
->simd_clones
)
476 for (next
= cnode
->simd_clones
;
478 next
= next
->simdclone
->next_clone
)
480 || !reachable
.add (next
))
481 enqueue_node (next
, &first
, &reachable
);
484 /* When we see constructor of external variable, keep referred nodes in the
485 boundary. This will also hold initializers of the external vars NODE
487 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
489 && DECL_EXTERNAL (node
->decl
)
493 struct ipa_ref
*ref
= NULL
;
494 for (int i
= 0; node
->iterate_reference (i
, ref
); i
++)
495 enqueue_node (ref
->referred
, &first
, &reachable
);
499 /* Remove unreachable functions. */
500 for (node
= first_function (); node
; node
= next
)
502 next
= next_function (node
);
504 /* If node is not needed at all, remove it. */
508 fprintf (file
, " %s", node
->dump_name ());
512 /* If node is unreachable, remove its body. */
513 else if (!reachable
.contains (node
))
515 /* We keep definitions of thunks and aliases in the boundary so
516 we can walk to the ultimate alias targets and function symbols
518 if (node
->alias
|| node
->thunk
.thunk_p
)
520 else if (!body_needed_for_clonning
.contains (node
->decl
)
521 && !node
->alias
&& !node
->thunk
.thunk_p
)
522 node
->release_body ();
523 else if (!node
->clone_of
)
524 gcc_assert (in_lto_p
|| DECL_RESULT (node
->decl
));
525 if (node
->definition
&& !node
->alias
&& !node
->thunk
.thunk_p
)
528 fprintf (file
, " %s", node
->dump_name ());
529 node
->body_removed
= true;
530 node
->analyzed
= false;
531 node
->definition
= false;
532 node
->cpp_implicit_alias
= false;
534 node
->transparent_alias
= false;
535 node
->thunk
.thunk_p
= false;
536 node
->weakref
= false;
537 /* After early inlining we drop always_inline attributes on
538 bodies of functions that are still referenced (have their
540 DECL_ATTRIBUTES (node
->decl
)
541 = remove_attribute ("always_inline",
542 DECL_ATTRIBUTES (node
->decl
));
543 if (!node
->in_other_partition
)
544 node
->local
.local
= false;
545 node
->remove_callees ();
546 node
->remove_all_references ();
548 if (node
->thunk
.thunk_p
549 && node
->thunk
.add_pointer_bounds_args
)
551 node
->thunk
.thunk_p
= false;
552 node
->thunk
.add_pointer_bounds_args
= false;
557 gcc_assert (node
->clone_of
|| !node
->has_gimple_body_p ()
558 || in_lto_p
|| DECL_RESULT (node
->decl
));
561 /* Inline clones might be kept around so their materializing allows further
562 cloning. If the function the clone is inlined into is removed, we need
563 to turn it into normal cone. */
564 FOR_EACH_FUNCTION (node
)
566 if (node
->global
.inlined_to
569 gcc_assert (node
->clones
);
570 node
->global
.inlined_to
= NULL
;
571 update_inlined_to_pointer (node
, node
);
576 /* Remove unreachable variables. */
578 fprintf (file
, "\nReclaiming variables:");
579 for (vnode
= first_variable (); vnode
; vnode
= vnext
)
581 vnext
= next_variable (vnode
);
583 /* For can_refer_decl_in_current_unit_p we want to track for
584 all external variables if they are defined in other partition
586 && (!flag_ltrans
|| !DECL_EXTERNAL (vnode
->decl
)))
588 struct ipa_ref
*ref
= NULL
;
590 /* First remove the aliases, so varpool::remove can possibly lookup
591 the constructor and save it for future use. */
592 while (vnode
->iterate_direct_aliases (0, ref
))
595 fprintf (file
, " %s", ref
->referred
->dump_name ());
596 ref
->referring
->remove ();
599 fprintf (file
, " %s", vnode
->dump_name ());
600 vnext
= next_variable (vnode
);
601 /* Signal removal to the debug machinery. */
602 if (! flag_wpa
|| flag_incremental_link
== INCREMENTAL_LINK_LTO
)
604 vnode
->definition
= false;
605 (*debug_hooks
->late_global_decl
) (vnode
->decl
);
610 else if (!reachable
.contains (vnode
) && !vnode
->alias
)
613 if (vnode
->definition
)
616 fprintf (file
, " %s", vnode
->name ());
619 /* Keep body if it may be useful for constant folding. */
620 if ((flag_wpa
|| flag_incremental_link
== INCREMENTAL_LINK_LTO
)
621 || ((init
= ctor_for_folding (vnode
->decl
)) == error_mark_node
))
622 vnode
->remove_initializer ();
624 DECL_INITIAL (vnode
->decl
) = init
;
625 vnode
->body_removed
= true;
626 vnode
->definition
= false;
627 vnode
->analyzed
= false;
630 vnode
->remove_from_same_comdat_group ();
632 vnode
->remove_all_references ();
638 /* Now update address_taken flags and try to promote functions to be local. */
640 fprintf (file
, "\nClearing address taken flags:");
641 FOR_EACH_DEFINED_FUNCTION (node
)
642 if (node
->address_taken
643 && !node
->used_from_other_partition
)
645 if (!node
->call_for_symbol_and_aliases
646 (has_addr_references_p
, NULL
, true))
649 fprintf (file
, " %s", node
->name ());
650 node
->address_taken
= false;
653 /* Virtual functions may be kept in cgraph just because
654 of possible later devirtualization. Do not mark them as
655 local too early so we won't optimize them out before
656 we are done with polymorphic call analysis. */
657 && (!before_inlining_p
658 || !node
->call_for_symbol_and_aliases
659 (is_indirect_call_target_p
, NULL
, true)))
661 node
->local
.local
= true;
663 fprintf (file
, " (local)");
668 fprintf (file
, "\n");
670 symtab_node::checking_verify_symtab_nodes ();
672 /* If we removed something, perhaps profile could be improved. */
673 if (changed
&& (optimize
|| in_lto_p
) && ipa_call_summaries
)
674 FOR_EACH_DEFINED_FUNCTION (node
)
675 ipa_propagate_frequency (node
);
677 timevar_pop (TV_IPA_UNREACHABLE
);
681 /* Process references to VNODE and set flags WRITTEN, ADDRESS_TAKEN, READ
682 as needed, also clear EXPLICIT_REFS if the references to given variable
683 do not need to be explicit. */
686 process_references (varpool_node
*vnode
,
687 bool *written
, bool *address_taken
,
688 bool *read
, bool *explicit_refs
)
693 if (!vnode
->all_refs_explicit_p ()
694 || TREE_THIS_VOLATILE (vnode
->decl
))
695 *explicit_refs
= false;
697 for (i
= 0; vnode
->iterate_referring (i
, ref
)
698 && *explicit_refs
&& (!*written
|| !*address_taken
|| !*read
); i
++)
702 *address_taken
= true;
711 process_references (dyn_cast
<varpool_node
*> (ref
->referring
), written
,
712 address_taken
, read
, explicit_refs
);
717 /* Set TREE_READONLY bit. */
720 set_readonly_bit (varpool_node
*vnode
, void *data ATTRIBUTE_UNUSED
)
722 TREE_READONLY (vnode
->decl
) = true;
726 /* Set writeonly bit and clear the initalizer, since it will not be needed. */
729 set_writeonly_bit (varpool_node
*vnode
, void *data
)
731 vnode
->writeonly
= true;
732 if (optimize
|| in_lto_p
)
734 DECL_INITIAL (vnode
->decl
) = NULL
;
737 if (vnode
->num_references ())
738 *(bool *)data
= true;
739 vnode
->remove_all_references ();
745 /* Clear addressale bit of VNODE. */
748 clear_addressable_bit (varpool_node
*vnode
, void *data ATTRIBUTE_UNUSED
)
750 vnode
->address_taken
= false;
751 TREE_ADDRESSABLE (vnode
->decl
) = 0;
755 /* Discover variables that have no longer address taken, are read-only or
756 write-only and update their flags.
758 Return true when unreachable symbol removal should be done.
760 FIXME: This can not be done in between gimplify and omp_expand since
761 readonly flag plays role on what is shared and what is not. Currently we do
762 this transformation as part of whole program visibility and re-do at
763 ipa-reference pass (to take into account clonning), but it would
764 make sense to do it before early optimizations. */
767 ipa_discover_variable_flags (void)
769 if (!flag_ipa_reference_addressable
)
772 bool remove_p
= false;
775 fprintf (dump_file
, "Clearing variable flags:");
776 FOR_EACH_VARIABLE (vnode
)
778 && (TREE_ADDRESSABLE (vnode
->decl
)
780 || !TREE_READONLY (vnode
->decl
)))
782 bool written
= false;
783 bool address_taken
= false;
785 bool explicit_refs
= true;
787 process_references (vnode
, &written
, &address_taken
, &read
,
793 if (TREE_ADDRESSABLE (vnode
->decl
) && dump_file
)
794 fprintf (dump_file
, " %s (non-addressable)", vnode
->name ());
795 vnode
->call_for_symbol_and_aliases (clear_addressable_bit
, NULL
,
798 if (!address_taken
&& !written
799 /* Making variable in explicit section readonly can cause section
801 See e.g. gcc.c-torture/compile/pr23237.c */
802 && vnode
->get_section () == NULL
)
804 if (!TREE_READONLY (vnode
->decl
) && dump_file
)
805 fprintf (dump_file
, " %s (read-only)", vnode
->name ());
806 vnode
->call_for_symbol_and_aliases (set_readonly_bit
, NULL
, true);
808 if (!vnode
->writeonly
&& !read
&& !address_taken
&& written
)
811 fprintf (dump_file
, " %s (write-only)", vnode
->name ());
812 vnode
->call_for_symbol_and_aliases (set_writeonly_bit
, &remove_p
,
817 fprintf (dump_file
, "\n");
821 /* Generate and emit a static constructor or destructor. WHICH must
822 be one of 'I' (for a constructor), 'D' (for a destructor).
823 BODY is a STATEMENT_LIST containing GENERIC
824 statements. PRIORITY is the initialization priority for this
825 constructor or destructor.
827 FINAL specify whether the externally visible name for collect2 should
831 cgraph_build_static_cdtor_1 (char which
, tree body
, int priority
, bool final
)
833 static int counter
= 0;
835 tree decl
, name
, resdecl
;
837 /* The priority is encoded in the constructor or destructor name.
838 collect2 will sort the names and arrange that they are called at
841 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
843 /* Proudce sane name but one not recognizable by collect2, just for the
844 case we fail to inline the function. */
845 sprintf (which_buf
, "sub_%c_%.5d_%d", which
, priority
, counter
++);
846 name
= get_file_function_name (which_buf
);
848 decl
= build_decl (input_location
, FUNCTION_DECL
, name
,
849 build_function_type_list (void_type_node
, NULL_TREE
));
850 current_function_decl
= decl
;
852 resdecl
= build_decl (input_location
,
853 RESULT_DECL
, NULL_TREE
, void_type_node
);
854 DECL_ARTIFICIAL (resdecl
) = 1;
855 DECL_RESULT (decl
) = resdecl
;
856 DECL_CONTEXT (resdecl
) = decl
;
858 allocate_struct_function (decl
, false);
860 TREE_STATIC (decl
) = 1;
861 TREE_USED (decl
) = 1;
862 DECL_ARTIFICIAL (decl
) = 1;
863 DECL_IGNORED_P (decl
) = 1;
864 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
865 DECL_SAVED_TREE (decl
) = body
;
866 if (!targetm
.have_ctors_dtors
&& final
)
868 TREE_PUBLIC (decl
) = 1;
869 DECL_PRESERVE_P (decl
) = 1;
871 DECL_UNINLINABLE (decl
) = 1;
873 DECL_INITIAL (decl
) = make_node (BLOCK
);
874 BLOCK_SUPERCONTEXT (DECL_INITIAL (decl
)) = decl
;
875 TREE_USED (DECL_INITIAL (decl
)) = 1;
877 DECL_SOURCE_LOCATION (decl
) = input_location
;
878 cfun
->function_end_locus
= input_location
;
883 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
884 decl_init_priority_insert (decl
, priority
);
887 DECL_STATIC_DESTRUCTOR (decl
) = 1;
888 decl_fini_priority_insert (decl
, priority
);
894 gimplify_function_tree (decl
);
896 cgraph_node::add_new_function (decl
, false);
899 current_function_decl
= NULL
;
902 /* Generate and emit a static constructor or destructor. WHICH must
903 be one of 'I' (for a constructor) or 'D' (for a destructor).
904 BODY is a STATEMENT_LIST containing GENERIC
905 statements. PRIORITY is the initialization priority for this
906 constructor or destructor. */
909 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
911 cgraph_build_static_cdtor_1 (which
, body
, priority
, false);
914 /* When target does not have ctors and dtors, we call all constructor
915 and destructor by special initialization/destruction function
916 recognized by collect2.
918 When we are going to build this function, collect all constructors and
919 destructors and turn them into normal functions. */
922 record_cdtor_fn (struct cgraph_node
*node
, vec
<tree
> *ctors
, vec
<tree
> *dtors
)
924 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
925 ctors
->safe_push (node
->decl
);
926 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
927 dtors
->safe_push (node
->decl
);
928 node
= cgraph_node::get (node
->decl
);
929 DECL_DISREGARD_INLINE_LIMITS (node
->decl
) = 1;
932 /* Define global constructors/destructor functions for the CDTORS, of
933 which they are LEN. The CDTORS are sorted by initialization
934 priority. If CTOR_P is true, these are constructors; otherwise,
935 they are destructors. */
938 build_cdtor (bool ctor_p
, const vec
<tree
> &cdtors
)
941 size_t len
= cdtors
.length ();
948 priority_type priority
;
957 p
= ctor_p
? DECL_INIT_PRIORITY (fn
) : DECL_FINI_PRIORITY (fn
);
960 else if (p
!= priority
)
966 /* When there is only one cdtor and target supports them, do nothing. */
968 && targetm
.have_ctors_dtors
)
973 /* Find the next batch of constructors/destructors with the same
974 initialization priority. */
979 call
= build_call_expr (fn
, 0);
981 DECL_STATIC_CONSTRUCTOR (fn
) = 0;
983 DECL_STATIC_DESTRUCTOR (fn
) = 0;
984 /* We do not want to optimize away pure/const calls here.
985 When optimizing, these should be already removed, when not
986 optimizing, we want user to be able to breakpoint in them. */
987 TREE_SIDE_EFFECTS (call
) = 1;
988 append_to_statement_list (call
, &body
);
990 gcc_assert (body
!= NULL_TREE
);
991 /* Generate a function to call all the function of like
993 cgraph_build_static_cdtor_1 (ctor_p
? 'I' : 'D', body
, priority
, true);
997 /* Comparison function for qsort. P1 and P2 are actually of type
998 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
999 used to determine the sort order. */
1002 compare_ctor (const void *p1
, const void *p2
)
1009 f1
= *(const tree
*)p1
;
1010 f2
= *(const tree
*)p2
;
1011 priority1
= DECL_INIT_PRIORITY (f1
);
1012 priority2
= DECL_INIT_PRIORITY (f2
);
1014 if (priority1
< priority2
)
1016 else if (priority1
> priority2
)
1019 /* Ensure a stable sort. Constructors are executed in backwarding
1020 order to make LTO initialize braries first. */
1021 return DECL_UID (f2
) - DECL_UID (f1
);
1024 /* Comparison function for qsort. P1 and P2 are actually of type
1025 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
1026 used to determine the sort order. */
1029 compare_dtor (const void *p1
, const void *p2
)
1036 f1
= *(const tree
*)p1
;
1037 f2
= *(const tree
*)p2
;
1038 priority1
= DECL_FINI_PRIORITY (f1
);
1039 priority2
= DECL_FINI_PRIORITY (f2
);
1041 if (priority1
< priority2
)
1043 else if (priority1
> priority2
)
1046 /* Ensure a stable sort. */
1047 return DECL_UID (f1
) - DECL_UID (f2
);
1050 /* Generate functions to call static constructors and destructors
1051 for targets that do not support .ctors/.dtors sections. These
1052 functions have magic names which are detected by collect2. */
1055 build_cdtor_fns (vec
<tree
> *ctors
, vec
<tree
> *dtors
)
1057 if (!ctors
->is_empty ())
1059 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1060 ctors
->qsort (compare_ctor
);
1061 build_cdtor (/*ctor_p=*/true, *ctors
);
1064 if (!dtors
->is_empty ())
1066 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1067 dtors
->qsort (compare_dtor
);
1068 build_cdtor (/*ctor_p=*/false, *dtors
);
1072 /* Look for constructors and destructors and produce function calling them.
1073 This is needed for targets not supporting ctors or dtors, but we perform the
1074 transformation also at linktime to merge possibly numerous
1075 constructors/destructors into single function to improve code locality and
1079 ipa_cdtor_merge (void)
1081 /* A vector of FUNCTION_DECLs declared as static constructors. */
1082 auto_vec
<tree
, 20> ctors
;
1083 /* A vector of FUNCTION_DECLs declared as static destructors. */
1084 auto_vec
<tree
, 20> dtors
;
1085 struct cgraph_node
*node
;
1086 FOR_EACH_DEFINED_FUNCTION (node
)
1087 if (DECL_STATIC_CONSTRUCTOR (node
->decl
)
1088 || DECL_STATIC_DESTRUCTOR (node
->decl
))
1089 record_cdtor_fn (node
, &ctors
, &dtors
);
1090 build_cdtor_fns (&ctors
, &dtors
);
1096 const pass_data pass_data_ipa_cdtor_merge
=
1098 IPA_PASS
, /* type */
1100 OPTGROUP_NONE
, /* optinfo_flags */
1101 TV_CGRAPHOPT
, /* tv_id */
1102 0, /* properties_required */
1103 0, /* properties_provided */
1104 0, /* properties_destroyed */
1105 0, /* todo_flags_start */
1106 0, /* todo_flags_finish */
1109 class pass_ipa_cdtor_merge
: public ipa_opt_pass_d
1112 pass_ipa_cdtor_merge (gcc::context
*ctxt
)
1113 : ipa_opt_pass_d (pass_data_ipa_cdtor_merge
, ctxt
,
1114 NULL
, /* generate_summary */
1115 NULL
, /* write_summary */
1116 NULL
, /* read_summary */
1117 NULL
, /* write_optimization_summary */
1118 NULL
, /* read_optimization_summary */
1119 NULL
, /* stmt_fixup */
1120 0, /* function_transform_todo_flags_start */
1121 NULL
, /* function_transform */
1122 NULL
) /* variable_transform */
1125 /* opt_pass methods: */
1126 virtual bool gate (function
*);
1127 virtual unsigned int execute (function
*) { return ipa_cdtor_merge (); }
1129 }; // class pass_ipa_cdtor_merge
1132 pass_ipa_cdtor_merge::gate (function
*)
1134 /* Perform the pass when we have no ctors/dtors support
1135 or at LTO time to merge multiple constructors into single
1137 return !targetm
.have_ctors_dtors
|| in_lto_p
;
1143 make_pass_ipa_cdtor_merge (gcc::context
*ctxt
)
1145 return new pass_ipa_cdtor_merge (ctxt
);
1148 /* Invalid pointer representing BOTTOM for single user dataflow. */
1149 #define BOTTOM ((cgraph_node *)(size_t) 2)
1151 /* Meet operation for single user dataflow.
1152 Here we want to associate variables with sigle function that may access it.
1154 FUNCTION is current single user of a variable, VAR is variable that uses it.
1155 Latttice is stored in SINGLE_USER_MAP.
1158 - TOP by no entry in SIGNLE_USER_MAP
1159 - BOTTOM by BOTTOM in AUX pointer (to save lookups)
1160 - known single user by cgraph pointer in SINGLE_USER_MAP. */
1163 meet (cgraph_node
*function
, varpool_node
*var
,
1164 hash_map
<varpool_node
*, cgraph_node
*> &single_user_map
)
1166 struct cgraph_node
*user
, **f
;
1168 if (var
->aux
== BOTTOM
)
1171 f
= single_user_map
.get (var
);
1177 else if (function
!= user
)
1183 /* Propagation step of single-use dataflow.
1185 Check all uses of VNODE and see if they are used by single function FUNCTION.
1186 SINGLE_USER_MAP represents the dataflow lattice. */
1189 propagate_single_user (varpool_node
*vnode
, cgraph_node
*function
,
1190 hash_map
<varpool_node
*, cgraph_node
*> &single_user_map
)
1193 struct ipa_ref
*ref
;
1195 gcc_assert (!vnode
->externally_visible
);
1197 /* If node is an alias, first meet with its target. */
1199 function
= meet (function
, vnode
->get_alias_target (), single_user_map
);
1201 /* Check all users and see if they correspond to a single function. */
1202 for (i
= 0; vnode
->iterate_referring (i
, ref
) && function
!= BOTTOM
; i
++)
1204 struct cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (ref
->referring
);
1207 if (cnode
->global
.inlined_to
)
1208 cnode
= cnode
->global
.inlined_to
;
1211 else if (function
!= cnode
)
1215 function
= meet (function
, dyn_cast
<varpool_node
*> (ref
->referring
),
1221 /* Pass setting used_by_single_function flag.
1222 This flag is set on variable when there is only one function that may
1223 possibly referr to it. */
1226 ipa_single_use (void)
1228 varpool_node
*first
= (varpool_node
*) (void *) 1;
1230 hash_map
<varpool_node
*, cgraph_node
*> single_user_map
;
1232 FOR_EACH_DEFINED_VARIABLE (var
)
1233 if (!var
->all_refs_explicit_p ())
1237 /* Enqueue symbol for dataflow. */
1242 /* The actual dataflow. */
1244 while (first
!= (void *) 1)
1246 cgraph_node
*user
, *orig_user
, **f
;
1249 first
= (varpool_node
*)first
->aux
;
1251 f
= single_user_map
.get (var
);
1256 user
= propagate_single_user (var
, orig_user
, single_user_map
);
1258 gcc_checking_assert (var
->aux
!= BOTTOM
);
1260 /* If user differs, enqueue all references. */
1261 if (user
!= orig_user
)
1266 single_user_map
.put (var
, user
);
1268 /* Enqueue all aliases for re-processing. */
1269 for (i
= 0; var
->iterate_direct_aliases (i
, ref
); i
++)
1270 if (!ref
->referring
->aux
)
1272 ref
->referring
->aux
= first
;
1273 first
= dyn_cast
<varpool_node
*> (ref
->referring
);
1275 /* Enqueue all users for re-processing. */
1276 for (i
= 0; var
->iterate_reference (i
, ref
); i
++)
1277 if (!ref
->referred
->aux
1278 && ref
->referred
->definition
1279 && is_a
<varpool_node
*> (ref
->referred
))
1281 ref
->referred
->aux
= first
;
1282 first
= dyn_cast
<varpool_node
*> (ref
->referred
);
1285 /* If user is BOTTOM, just punt on this var. */
1295 FOR_EACH_DEFINED_VARIABLE (var
)
1297 if (var
->aux
!= BOTTOM
)
1299 /* Not having the single user known means that the VAR is
1300 unreachable. Either someone forgot to remove unreachable
1301 variables or the reachability here is wrong. */
1303 gcc_checking_assert (single_user_map
.get (var
));
1307 fprintf (dump_file
, "Variable %s is used by single function\n",
1310 var
->used_by_single_function
= true;
1319 const pass_data pass_data_ipa_single_use
=
1321 IPA_PASS
, /* type */
1322 "single-use", /* name */
1323 OPTGROUP_NONE
, /* optinfo_flags */
1324 TV_CGRAPHOPT
, /* tv_id */
1325 0, /* properties_required */
1326 0, /* properties_provided */
1327 0, /* properties_destroyed */
1328 0, /* todo_flags_start */
1329 0, /* todo_flags_finish */
1332 class pass_ipa_single_use
: public ipa_opt_pass_d
1335 pass_ipa_single_use (gcc::context
*ctxt
)
1336 : ipa_opt_pass_d (pass_data_ipa_single_use
, ctxt
,
1337 NULL
, /* generate_summary */
1338 NULL
, /* write_summary */
1339 NULL
, /* read_summary */
1340 NULL
, /* write_optimization_summary */
1341 NULL
, /* read_optimization_summary */
1342 NULL
, /* stmt_fixup */
1343 0, /* function_transform_todo_flags_start */
1344 NULL
, /* function_transform */
1345 NULL
) /* variable_transform */
1348 /* opt_pass methods: */
1349 virtual unsigned int execute (function
*) { return ipa_single_use (); }
1351 }; // class pass_ipa_single_use
1356 make_pass_ipa_single_use (gcc::context
*ctxt
)
1358 return new pass_ipa_single_use (ctxt
);
1361 /* Materialize all clones. */
1365 const pass_data pass_data_materialize_all_clones
=
1367 SIMPLE_IPA_PASS
, /* type */
1368 "materialize-all-clones", /* name */
1369 OPTGROUP_NONE
, /* optinfo_flags */
1370 TV_IPA_OPT
, /* tv_id */
1371 0, /* properties_required */
1372 0, /* properties_provided */
1373 0, /* properties_destroyed */
1374 0, /* todo_flags_start */
1375 0, /* todo_flags_finish */
1378 class pass_materialize_all_clones
: public simple_ipa_opt_pass
1381 pass_materialize_all_clones (gcc::context
*ctxt
)
1382 : simple_ipa_opt_pass (pass_data_materialize_all_clones
, ctxt
)
1385 /* opt_pass methods: */
1386 virtual unsigned int execute (function
*)
1388 symtab
->materialize_all_clones ();
1392 }; // class pass_materialize_all_clones
1396 simple_ipa_opt_pass
*
1397 make_pass_materialize_all_clones (gcc::context
*ctxt
)
1399 return new pass_materialize_all_clones (ctxt
);