1 /* Basic IPA optimizations and utilities.
2 Copyright (C) 2003-2015 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"
26 #include "hard-reg-set.h"
29 #include "fold-const.h"
31 #include "stringpool.h"
33 #include "tree-pass.h"
37 #include "tree-iterator.h"
38 #include "ipa-utils.h"
39 #include "alloc-pool.h"
40 #include "symbol-summary.h"
42 #include "ipa-inline.h"
43 #include "tree-inline.h"
46 #include "internal-fn.h"
50 /* Return true when NODE has ADDR reference. */
53 has_addr_references_p (struct cgraph_node
*node
,
54 void *data ATTRIBUTE_UNUSED
)
57 struct ipa_ref
*ref
= NULL
;
59 for (i
= 0; node
->iterate_referring (i
, ref
); i
++)
60 if (ref
->use
== IPA_REF_ADDR
)
65 /* Look for all functions inlined to NODE and update their inlined_to pointers
69 update_inlined_to_pointer (struct cgraph_node
*node
, struct cgraph_node
*inlined_to
)
71 struct cgraph_edge
*e
;
72 for (e
= node
->callees
; e
; e
= e
->next_callee
)
73 if (e
->callee
->global
.inlined_to
)
75 e
->callee
->global
.inlined_to
= inlined_to
;
76 update_inlined_to_pointer (e
->callee
, inlined_to
);
80 /* Add symtab NODE to queue starting at FIRST.
82 The queue is linked via AUX pointers and terminated by pointer to 1.
83 We enqueue nodes at two occasions: when we find them reachable or when we find
84 their bodies needed for further clonning. In the second case we mark them
85 by pointer to 2 after processing so they are re-queue when they become
89 enqueue_node (symtab_node
*node
, symtab_node
**first
,
90 hash_set
<symtab_node
*> *reachable
)
92 /* Node is still in queue; do nothing. */
93 if (node
->aux
&& node
->aux
!= (void *) 2)
95 /* Node was already processed as unreachable, re-enqueue
96 only if it became reachable now. */
97 if (node
->aux
== (void *)2 && !reachable
->contains (node
))
103 /* Process references. */
106 process_references (symtab_node
*snode
,
108 bool before_inlining_p
,
109 hash_set
<symtab_node
*> *reachable
)
112 struct ipa_ref
*ref
= NULL
;
113 for (i
= 0; snode
->iterate_reference (i
, ref
); i
++)
115 symtab_node
*node
= ref
->referred
;
116 symtab_node
*body
= node
->ultimate_alias_target ();
118 if (node
->definition
&& !node
->in_other_partition
119 && ((!DECL_EXTERNAL (node
->decl
) || node
->alias
)
120 || (((before_inlining_p
121 && ((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 || (TREE_CODE (node
->decl
) == VAR_DECL
134 && ctor_for_folding (node
->decl
)
135 != error_mark_node
))))
137 /* Be sure that we will not optimize out alias target
139 if (DECL_EXTERNAL (node
->decl
)
141 && before_inlining_p
)
142 reachable
->add (body
);
143 reachable
->add (node
);
145 enqueue_node (node
, first
, reachable
);
149 /* EDGE is an polymorphic call. If BEFORE_INLINING_P is set, mark
150 all its potential targets as reachable to permit later inlining if
151 devirtualization happens. After inlining still keep their declarations
152 around, so we can devirtualize to a direct call.
154 Also try to make trivial devirutalization when no or only one target is
158 walk_polymorphic_call_targets (hash_set
<void *> *reachable_call_targets
,
159 struct cgraph_edge
*edge
,
161 hash_set
<symtab_node
*> *reachable
,
162 bool before_inlining_p
)
167 vec
<cgraph_node
*>targets
168 = possible_polymorphic_call_targets
169 (edge
, &final
, &cache_token
);
171 if (!reachable_call_targets
->add (cache_token
))
173 for (i
= 0; i
< targets
.length (); i
++)
175 struct cgraph_node
*n
= targets
[i
];
177 /* Do not bother to mark virtual methods in anonymous namespace;
178 either we will find use of virtual table defining it, or it is
180 if (TREE_CODE (TREE_TYPE (n
->decl
)) == METHOD_TYPE
181 && type_in_anonymous_namespace_p
182 (TYPE_METHOD_BASETYPE (TREE_TYPE (n
->decl
))))
185 symtab_node
*body
= n
->function_symbol ();
187 /* Prior inlining, keep alive bodies of possible targets for
190 && (before_inlining_p
191 && opt_for_fn (body
->decl
, optimize
)
192 && opt_for_fn (body
->decl
, flag_devirtualize
)))
194 /* Be sure that we will not optimize out alias target
196 if (DECL_EXTERNAL (n
->decl
)
198 && before_inlining_p
)
199 reachable
->add (body
);
202 /* Even after inlining we want to keep the possible targets in the
203 boundary, so late passes can still produce direct call even if
204 the chance for inlining is lost. */
205 enqueue_node (n
, first
, reachable
);
209 /* Very trivial devirtualization; when the type is
210 final or anonymous (so we know all its derivation)
211 and there is only one possible virtual call target,
212 make the edge direct. */
215 if (targets
.length () <= 1 && dbg_cnt (devirt
))
217 cgraph_node
*target
, *node
= edge
->caller
;
218 if (targets
.length () == 1)
221 target
= cgraph_node::get_create
222 (builtin_decl_implicit (BUILT_IN_UNREACHABLE
));
224 if (dump_enabled_p ())
228 locus
= gimple_location (edge
->call_stmt
);
230 locus
= UNKNOWN_LOCATION
;
231 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, locus
,
232 "devirtualizing call in %s/%i to %s/%i\n",
233 edge
->caller
->name (), edge
->caller
->order
,
237 edge
= edge
->make_direct (target
);
238 if (inline_summaries
)
239 inline_update_overall_summary (node
);
240 else if (edge
->call_stmt
)
242 edge
->redirect_call_stmt_to_callee ();
244 /* Call to __builtin_unreachable shouldn't be instrumented. */
245 if (!targets
.length ())
246 gimple_call_set_with_bounds (edge
->call_stmt
, false);
252 /* Perform reachability analysis and reclaim all unreachable nodes.
254 The algorithm is basically mark&sweep but with some extra refinements:
256 - reachable extern inline functions needs special handling; the bodies needs
257 to stay in memory until inlining in hope that they will be inlined.
258 After inlining we release their bodies and turn them into unanalyzed
259 nodes even when they are reachable.
261 - virtual functions are kept in callgraph even if they seem unreachable in
262 hope calls to them will be devirtualized.
264 Again we remove them after inlining. In late optimization some
265 devirtualization may happen, but it is not important since we won't inline
266 the call. In theory early opts and IPA should work out all important cases.
268 - virtual clones needs bodies of their origins for later materialization;
269 this means that we want to keep the body even if the origin is unreachable
270 otherwise. To avoid origin from sitting in the callgraph and being
271 walked by IPA passes, we turn them into unanalyzed nodes with body
274 We maintain set of function declaration where body needs to stay in
275 body_needed_for_clonning
277 Inline clones represent special case: their declaration match the
278 declaration of origin and cgraph_remove_node already knows how to
279 reshape callgraph and preserve body when offline copy of function or
280 inline clone is being removed.
282 - C++ virtual tables keyed to other unit are represented as DECL_EXTERNAL
283 variables with DECL_INITIAL set. We finalize these and keep reachable
284 ones around for constant folding purposes. After inlining we however
285 stop walking their references to let everything static referneced by them
286 to be removed when it is otherwise unreachable.
288 We maintain queue of both reachable symbols (i.e. defined symbols that needs
289 to stay) and symbols that are in boundary (i.e. external symbols referenced
290 by reachable symbols or origins of clones). The queue is represented
291 as linked list by AUX pointer terminated by 1.
293 At the end we keep all reachable symbols. For symbols in boundary we always
294 turn definition into a declaration, but we may keep function body around
295 based on body_needed_for_clonning
297 All symbols that enter the queue have AUX pointer non-zero and are in the
298 boundary. Pointer set REACHABLE is used to track reachable symbols.
300 Every symbol can be visited twice - once as part of boundary and once
301 as real reachable symbol. enqueue_node needs to decide whether the
302 node needs to be re-queued for second processing. For this purpose
303 we set AUX pointer of processed symbols in the boundary to constant 2. */
306 symbol_table::remove_unreachable_nodes (FILE *file
)
308 symtab_node
*first
= (symtab_node
*) (void *) 1;
309 struct cgraph_node
*node
, *next
;
310 varpool_node
*vnode
, *vnext
;
311 bool changed
= false;
312 hash_set
<symtab_node
*> reachable
;
313 hash_set
<tree
> body_needed_for_clonning
;
314 hash_set
<void *> reachable_call_targets
;
315 bool before_inlining_p
= symtab
->state
< (!optimize
? IPA_SSA
316 : IPA_SSA_AFTER_INLINING
);
318 timevar_push (TV_IPA_UNREACHABLE
);
319 build_type_inheritance_graph ();
321 fprintf (file
, "\nReclaiming functions:");
322 #ifdef ENABLE_CHECKING
323 FOR_EACH_FUNCTION (node
)
324 gcc_assert (!node
->aux
);
325 FOR_EACH_VARIABLE (vnode
)
326 gcc_assert (!vnode
->aux
);
328 /* Mark functions whose bodies are obviously needed.
329 This is mostly when they can be referenced externally. Inline clones
330 are special since their declarations are shared with master clone and thus
331 cgraph_can_remove_if_no_direct_calls_and_refs_p should not be called on them. */
332 FOR_EACH_FUNCTION (node
)
334 node
->used_as_abstract_origin
= false;
336 && !node
->global
.inlined_to
337 && !node
->in_other_partition
338 && !node
->can_remove_if_no_direct_calls_and_refs_p ())
340 gcc_assert (!node
->global
.inlined_to
);
341 reachable
.add (node
);
342 enqueue_node (node
, &first
, &reachable
);
345 gcc_assert (!node
->aux
);
348 /* Mark variables that are obviously needed. */
349 FOR_EACH_DEFINED_VARIABLE (vnode
)
350 if (!vnode
->can_remove_if_no_refs_p()
351 && !vnode
->in_other_partition
)
353 reachable
.add (vnode
);
354 enqueue_node (vnode
, &first
, &reachable
);
357 /* Perform reachability analysis. */
358 while (first
!= (symtab_node
*) (void *) 1)
360 bool in_boundary_p
= !reachable
.contains (first
);
361 symtab_node
*node
= first
;
363 first
= (symtab_node
*)first
->aux
;
365 /* If we are processing symbol in boundary, mark its AUX pointer for
366 possible later re-processing in enqueue_node. */
369 node
->aux
= (void *)2;
370 if (node
->alias
&& node
->analyzed
)
371 enqueue_node (node
->get_alias_target (), &first
, &reachable
);
375 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
376 && DECL_ABSTRACT_ORIGIN (node
->decl
))
378 struct cgraph_node
*origin_node
379 = cgraph_node::get (DECL_ABSTRACT_ORIGIN (node
->decl
));
380 if (origin_node
&& !origin_node
->used_as_abstract_origin
)
382 origin_node
->used_as_abstract_origin
= true;
383 gcc_assert (!origin_node
->prev_sibling_clone
);
384 gcc_assert (!origin_node
->next_sibling_clone
);
385 for (cgraph_node
*n
= origin_node
->clones
; n
;
386 n
= n
->next_sibling_clone
)
387 if (n
->decl
== DECL_ABSTRACT_ORIGIN (node
->decl
))
388 n
->used_as_abstract_origin
= true;
391 /* If any symbol in a comdat group is reachable, force
392 all externally visible symbols in the same comdat
393 group to be reachable as well. Comdat-local symbols
394 can be discarded if all uses were inlined. */
395 if (node
->same_comdat_group
)
398 for (next
= node
->same_comdat_group
;
400 next
= next
->same_comdat_group
)
401 if (!next
->comdat_local_p ()
402 && !reachable
.add (next
))
403 enqueue_node (next
, &first
, &reachable
);
405 /* Mark references as reachable. */
406 process_references (node
, &first
, before_inlining_p
, &reachable
);
409 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
))
411 /* Mark the callees reachable unless they are direct calls to extern
412 inline functions we decided to not inline. */
415 struct cgraph_edge
*e
;
416 /* Keep alive possible targets for devirtualization. */
417 if (opt_for_fn (cnode
->decl
, optimize
)
418 && opt_for_fn (cnode
->decl
, flag_devirtualize
))
420 struct cgraph_edge
*next
;
421 for (e
= cnode
->indirect_calls
; e
; e
= next
)
423 next
= e
->next_callee
;
424 if (e
->indirect_info
->polymorphic
)
425 walk_polymorphic_call_targets (&reachable_call_targets
,
426 e
, &first
, &reachable
,
430 for (e
= cnode
->callees
; e
; e
= e
->next_callee
)
432 symtab_node
*body
= e
->callee
->function_symbol ();
433 if (e
->callee
->definition
434 && !e
->callee
->in_other_partition
435 && (!e
->inline_failed
436 || !DECL_EXTERNAL (e
->callee
->decl
)
438 || (before_inlining_p
439 && (opt_for_fn (body
->decl
, optimize
)
440 || (symtab
->state
< IPA_SSA
443 DECL_ATTRIBUTES (body
->decl
)))))))
445 /* Be sure that we will not optimize out alias target
447 if (DECL_EXTERNAL (e
->callee
->decl
)
449 && before_inlining_p
)
450 reachable
.add (body
);
451 reachable
.add (e
->callee
);
453 enqueue_node (e
->callee
, &first
, &reachable
);
456 /* When inline clone exists, mark body to be preserved so when removing
457 offline copy of the function we don't kill it. */
458 if (cnode
->global
.inlined_to
)
459 body_needed_for_clonning
.add (cnode
->decl
);
461 /* For instrumentation clones we always need original
462 function node for proper LTO privatization. */
463 if (cnode
->instrumentation_clone
464 && cnode
->definition
)
466 gcc_assert (cnode
->instrumented_version
|| in_lto_p
);
467 if (cnode
->instrumented_version
)
469 enqueue_node (cnode
->instrumented_version
, &first
,
471 reachable
.add (cnode
->instrumented_version
);
475 /* For non-inline clones, force their origins to the boundary and ensure
476 that body is not removed. */
477 while (cnode
->clone_of
)
479 bool noninline
= cnode
->clone_of
->decl
!= cnode
->decl
;
480 cnode
= cnode
->clone_of
;
483 body_needed_for_clonning
.add (cnode
->decl
);
484 enqueue_node (cnode
, &first
, &reachable
);
489 else if (cnode
->thunk
.thunk_p
)
490 enqueue_node (cnode
->callees
->callee
, &first
, &reachable
);
492 /* If any reachable function has simd clones, mark them as
493 reachable as well. */
494 if (cnode
->simd_clones
)
497 for (next
= cnode
->simd_clones
;
499 next
= next
->simdclone
->next_clone
)
501 || !reachable
.add (next
))
502 enqueue_node (next
, &first
, &reachable
);
505 /* When we see constructor of external variable, keep referred nodes in the
506 boundary. This will also hold initializers of the external vars NODE
508 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
510 && DECL_EXTERNAL (node
->decl
)
514 struct ipa_ref
*ref
= NULL
;
515 for (int i
= 0; node
->iterate_reference (i
, ref
); i
++)
516 enqueue_node (ref
->referred
, &first
, &reachable
);
520 /* Remove unreachable functions. */
521 for (node
= first_function (); node
; node
= next
)
523 next
= next_function (node
);
525 /* If node is not needed at all, remove it. */
529 fprintf (file
, " %s/%i", node
->name (), node
->order
);
533 /* If node is unreachable, remove its body. */
534 else if (!reachable
.contains (node
))
536 /* We keep definitions of thunks and aliases in the boundary so
537 we can walk to the ultimate alias targets and function symbols
539 if (node
->alias
|| node
->thunk
.thunk_p
)
541 else if (!body_needed_for_clonning
.contains (node
->decl
)
542 && !node
->alias
&& !node
->thunk
.thunk_p
)
543 node
->release_body ();
544 else if (!node
->clone_of
)
545 gcc_assert (in_lto_p
|| DECL_RESULT (node
->decl
));
546 if (node
->definition
&& !node
->alias
&& !node
->thunk
.thunk_p
)
549 fprintf (file
, " %s/%i", node
->name (), node
->order
);
550 node
->body_removed
= true;
551 node
->analyzed
= false;
552 node
->definition
= false;
553 node
->cpp_implicit_alias
= false;
555 node
->thunk
.thunk_p
= false;
556 node
->weakref
= false;
557 /* After early inlining we drop always_inline attributes on
558 bodies of functions that are still referenced (have their
560 DECL_ATTRIBUTES (node
->decl
)
561 = remove_attribute ("always_inline",
562 DECL_ATTRIBUTES (node
->decl
));
563 if (!node
->in_other_partition
)
564 node
->local
.local
= false;
565 node
->remove_callees ();
566 node
->remove_all_references ();
568 if (node
->thunk
.thunk_p
569 && node
->thunk
.add_pointer_bounds_args
)
571 node
->thunk
.thunk_p
= false;
572 node
->thunk
.add_pointer_bounds_args
= false;
577 gcc_assert (node
->clone_of
|| !node
->has_gimple_body_p ()
578 || in_lto_p
|| DECL_RESULT (node
->decl
));
581 /* Inline clones might be kept around so their materializing allows further
582 cloning. If the function the clone is inlined into is removed, we need
583 to turn it into normal cone. */
584 FOR_EACH_FUNCTION (node
)
586 if (node
->global
.inlined_to
589 gcc_assert (node
->clones
);
590 node
->global
.inlined_to
= NULL
;
591 update_inlined_to_pointer (node
, node
);
596 /* Remove unreachable variables. */
598 fprintf (file
, "\nReclaiming variables:");
599 for (vnode
= first_variable (); vnode
; vnode
= vnext
)
601 vnext
= next_variable (vnode
);
603 /* For can_refer_decl_in_current_unit_p we want to track for
604 all external variables if they are defined in other partition
606 && (!flag_ltrans
|| !DECL_EXTERNAL (vnode
->decl
)))
608 struct ipa_ref
*ref
= NULL
;
610 /* First remove the aliases, so varpool::remove can possibly lookup
611 the constructor and save it for future use. */
612 while (vnode
->iterate_direct_aliases (0, ref
))
615 fprintf (file
, " %s/%i", ref
->referred
->name (),
616 ref
->referred
->order
);
617 ref
->referring
->remove ();
620 fprintf (file
, " %s/%i", vnode
->name (), vnode
->order
);
621 vnext
= next_variable (vnode
);
625 else if (!reachable
.contains (vnode
) && !vnode
->alias
)
628 if (vnode
->definition
)
631 fprintf (file
, " %s", vnode
->name ());
634 /* Keep body if it may be useful for constant folding. */
635 if ((init
= ctor_for_folding (vnode
->decl
)) == error_mark_node
636 && !POINTER_BOUNDS_P (vnode
->decl
))
637 vnode
->remove_initializer ();
639 DECL_INITIAL (vnode
->decl
) = init
;
640 vnode
->body_removed
= true;
641 vnode
->definition
= false;
642 vnode
->analyzed
= false;
645 vnode
->remove_from_same_comdat_group ();
647 vnode
->remove_all_references ();
653 /* Now update address_taken flags and try to promote functions to be local. */
655 fprintf (file
, "\nClearing address taken flags:");
656 FOR_EACH_DEFINED_FUNCTION (node
)
657 if (node
->address_taken
658 && !node
->used_from_other_partition
)
660 if (!node
->call_for_symbol_and_aliases
661 (has_addr_references_p
, NULL
, true)
662 && (!node
->instrumentation_clone
663 || !node
->instrumented_version
664 || !node
->instrumented_version
->address_taken
))
667 fprintf (file
, " %s", node
->name ());
668 node
->address_taken
= false;
670 if (node
->local_p ())
672 node
->local
.local
= true;
674 fprintf (file
, " (local)");
679 fprintf (file
, "\n");
681 #ifdef ENABLE_CHECKING
682 symtab_node::verify_symtab_nodes ();
685 /* If we removed something, perhaps profile could be improved. */
686 if (changed
&& optimize
&& inline_edge_summary_vec
.exists ())
687 FOR_EACH_DEFINED_FUNCTION (node
)
688 ipa_propagate_frequency (node
);
690 timevar_pop (TV_IPA_UNREACHABLE
);
694 /* Process references to VNODE and set flags WRITTEN, ADDRESS_TAKEN, READ
695 as needed, also clear EXPLICIT_REFS if the references to given variable
696 do not need to be explicit. */
699 process_references (varpool_node
*vnode
,
700 bool *written
, bool *address_taken
,
701 bool *read
, bool *explicit_refs
)
706 if (!vnode
->all_refs_explicit_p ()
707 || TREE_THIS_VOLATILE (vnode
->decl
))
708 *explicit_refs
= false;
710 for (i
= 0; vnode
->iterate_referring (i
, ref
)
711 && *explicit_refs
&& (!*written
|| !*address_taken
|| !*read
); i
++)
715 *address_taken
= true;
724 process_references (dyn_cast
<varpool_node
*> (ref
->referring
), written
,
725 address_taken
, read
, explicit_refs
);
732 /* Set TREE_READONLY bit. */
735 set_readonly_bit (varpool_node
*vnode
, void *data ATTRIBUTE_UNUSED
)
737 TREE_READONLY (vnode
->decl
) = true;
741 /* Set writeonly bit and clear the initalizer, since it will not be needed. */
744 set_writeonly_bit (varpool_node
*vnode
, void *data
)
746 vnode
->writeonly
= true;
749 DECL_INITIAL (vnode
->decl
) = NULL
;
752 if (vnode
->num_references ())
753 *(bool *)data
= true;
754 vnode
->remove_all_references ();
760 /* Clear addressale bit of VNODE. */
763 clear_addressable_bit (varpool_node
*vnode
, void *data ATTRIBUTE_UNUSED
)
765 vnode
->address_taken
= false;
766 TREE_ADDRESSABLE (vnode
->decl
) = 0;
770 /* Discover variables that have no longer address taken or that are read only
771 and update their flags.
773 Return true when unreachable symbol removan should be done.
775 FIXME: This can not be done in between gimplify and omp_expand since
776 readonly flag plays role on what is shared and what is not. Currently we do
777 this transformation as part of whole program visibility and re-do at
778 ipa-reference pass (to take into account clonning), but it would
779 make sense to do it before early optimizations. */
782 ipa_discover_readonly_nonaddressable_vars (void)
784 bool remove_p
= false;
787 fprintf (dump_file
, "Clearing variable flags:");
788 FOR_EACH_VARIABLE (vnode
)
790 && (TREE_ADDRESSABLE (vnode
->decl
)
792 || !TREE_READONLY (vnode
->decl
)))
794 bool written
= false;
795 bool address_taken
= false;
797 bool explicit_refs
= true;
799 process_references (vnode
, &written
, &address_taken
, &read
,
805 if (TREE_ADDRESSABLE (vnode
->decl
) && dump_file
)
806 fprintf (dump_file
, " %s (non-addressable)", vnode
->name ());
807 vnode
->call_for_symbol_and_aliases (clear_addressable_bit
, NULL
,
810 if (!address_taken
&& !written
811 /* Making variable in explicit section readonly can cause section
813 See e.g. gcc.c-torture/compile/pr23237.c */
814 && vnode
->get_section () == NULL
)
816 if (!TREE_READONLY (vnode
->decl
) && dump_file
)
817 fprintf (dump_file
, " %s (read-only)", vnode
->name ());
818 vnode
->call_for_symbol_and_aliases (set_readonly_bit
, NULL
, true);
820 if (!vnode
->writeonly
&& !read
&& !address_taken
&& written
)
823 fprintf (dump_file
, " %s (write-only)", vnode
->name ());
824 vnode
->call_for_symbol_and_aliases (set_writeonly_bit
, &remove_p
,
829 fprintf (dump_file
, "\n");
833 /* Free inline summary. */
835 static const pass_data pass_data_ipa_free_inline_summary
=
837 SIMPLE_IPA_PASS
, /* type */
838 "free-inline-summary", /* name */
839 OPTGROUP_NONE
, /* optinfo_flags */
840 TV_IPA_FREE_INLINE_SUMMARY
, /* tv_id */
841 0, /* properties_required */
842 0, /* properties_provided */
843 0, /* properties_destroyed */
844 0, /* todo_flags_start */
845 /* Early optimizations may make function unreachable. We can not
846 remove unreachable functions as part of the ealry opts pass because
847 TODOs are run before subpasses. Do it here. */
848 ( TODO_remove_functions
| TODO_dump_symtab
), /* todo_flags_finish */
851 class pass_ipa_free_inline_summary GCC_FINAL
: public simple_ipa_opt_pass
854 pass_ipa_free_inline_summary (gcc::context
*ctxt
)
855 : simple_ipa_opt_pass (pass_data_ipa_free_inline_summary
, ctxt
)
858 /* opt_pass methods: */
859 virtual unsigned int execute (function
*)
861 inline_free_summary ();
865 }; // class pass_ipa_free_inline_summary
867 simple_ipa_opt_pass
*
868 make_pass_ipa_free_inline_summary (gcc::context
*ctxt
)
870 return new pass_ipa_free_inline_summary (ctxt
);
873 /* Generate and emit a static constructor or destructor. WHICH must
874 be one of 'I' (for a constructor), 'D' (for a destructor), 'P'
875 (for chp static vars constructor) or 'B' (for chkp static bounds
876 constructor). BODY is a STATEMENT_LIST containing GENERIC
877 statements. PRIORITY is the initialization priority for this
878 constructor or destructor.
880 FINAL specify whether the externally visible name for collect2 should
884 cgraph_build_static_cdtor_1 (char which
, tree body
, int priority
, bool final
)
886 static int counter
= 0;
888 tree decl
, name
, resdecl
;
890 /* The priority is encoded in the constructor or destructor name.
891 collect2 will sort the names and arrange that they are called at
894 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
896 /* Proudce sane name but one not recognizable by collect2, just for the
897 case we fail to inline the function. */
898 sprintf (which_buf
, "sub_%c_%.5d_%d", which
, priority
, counter
++);
899 name
= get_file_function_name (which_buf
);
901 decl
= build_decl (input_location
, FUNCTION_DECL
, name
,
902 build_function_type_list (void_type_node
, NULL_TREE
));
903 current_function_decl
= decl
;
905 resdecl
= build_decl (input_location
,
906 RESULT_DECL
, NULL_TREE
, void_type_node
);
907 DECL_ARTIFICIAL (resdecl
) = 1;
908 DECL_RESULT (decl
) = resdecl
;
909 DECL_CONTEXT (resdecl
) = decl
;
911 allocate_struct_function (decl
, false);
913 TREE_STATIC (decl
) = 1;
914 TREE_USED (decl
) = 1;
915 DECL_ARTIFICIAL (decl
) = 1;
916 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
917 DECL_SAVED_TREE (decl
) = body
;
918 if (!targetm
.have_ctors_dtors
&& final
)
920 TREE_PUBLIC (decl
) = 1;
921 DECL_PRESERVE_P (decl
) = 1;
923 DECL_UNINLINABLE (decl
) = 1;
925 DECL_INITIAL (decl
) = make_node (BLOCK
);
926 TREE_USED (DECL_INITIAL (decl
)) = 1;
928 DECL_SOURCE_LOCATION (decl
) = input_location
;
929 cfun
->function_end_locus
= input_location
;
934 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
935 decl_init_priority_insert (decl
, priority
);
938 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
939 DECL_ATTRIBUTES (decl
) = tree_cons (get_identifier ("chkp ctor"),
942 decl_init_priority_insert (decl
, priority
);
945 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
946 DECL_ATTRIBUTES (decl
) = tree_cons (get_identifier ("bnd_legacy"),
949 decl_init_priority_insert (decl
, priority
);
952 DECL_STATIC_DESTRUCTOR (decl
) = 1;
953 decl_fini_priority_insert (decl
, priority
);
959 gimplify_function_tree (decl
);
961 cgraph_node::add_new_function (decl
, false);
964 current_function_decl
= NULL
;
967 /* Generate and emit a static constructor or destructor. WHICH must
968 be one of 'I' (for a constructor), 'D' (for a destructor), 'P'
969 (for chkp static vars constructor) or 'B' (for chkp static bounds
970 constructor). BODY is a STATEMENT_LIST containing GENERIC
971 statements. PRIORITY is the initialization priority for this
972 constructor or destructor. */
975 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
977 cgraph_build_static_cdtor_1 (which
, body
, priority
, false);
980 /* A vector of FUNCTION_DECLs declared as static constructors. */
981 static vec
<tree
> static_ctors
;
982 /* A vector of FUNCTION_DECLs declared as static destructors. */
983 static vec
<tree
> static_dtors
;
985 /* When target does not have ctors and dtors, we call all constructor
986 and destructor by special initialization/destruction function
987 recognized by collect2.
989 When we are going to build this function, collect all constructors and
990 destructors and turn them into normal functions. */
993 record_cdtor_fn (struct cgraph_node
*node
)
995 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
996 static_ctors
.safe_push (node
->decl
);
997 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
998 static_dtors
.safe_push (node
->decl
);
999 node
= cgraph_node::get (node
->decl
);
1000 DECL_DISREGARD_INLINE_LIMITS (node
->decl
) = 1;
1003 /* Define global constructors/destructor functions for the CDTORS, of
1004 which they are LEN. The CDTORS are sorted by initialization
1005 priority. If CTOR_P is true, these are constructors; otherwise,
1006 they are destructors. */
1009 build_cdtor (bool ctor_p
, vec
<tree
> cdtors
)
1012 size_t len
= cdtors
.length ();
1019 priority_type priority
;
1028 p
= ctor_p
? DECL_INIT_PRIORITY (fn
) : DECL_FINI_PRIORITY (fn
);
1031 else if (p
!= priority
)
1037 /* When there is only one cdtor and target supports them, do nothing. */
1039 && targetm
.have_ctors_dtors
)
1044 /* Find the next batch of constructors/destructors with the same
1045 initialization priority. */
1050 call
= build_call_expr (fn
, 0);
1052 DECL_STATIC_CONSTRUCTOR (fn
) = 0;
1054 DECL_STATIC_DESTRUCTOR (fn
) = 0;
1055 /* We do not want to optimize away pure/const calls here.
1056 When optimizing, these should be already removed, when not
1057 optimizing, we want user to be able to breakpoint in them. */
1058 TREE_SIDE_EFFECTS (call
) = 1;
1059 append_to_statement_list (call
, &body
);
1061 gcc_assert (body
!= NULL_TREE
);
1062 /* Generate a function to call all the function of like
1064 cgraph_build_static_cdtor_1 (ctor_p
? 'I' : 'D', body
, priority
, true);
1068 /* Comparison function for qsort. P1 and P2 are actually of type
1069 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
1070 used to determine the sort order. */
1073 compare_ctor (const void *p1
, const void *p2
)
1080 f1
= *(const tree
*)p1
;
1081 f2
= *(const tree
*)p2
;
1082 priority1
= DECL_INIT_PRIORITY (f1
);
1083 priority2
= DECL_INIT_PRIORITY (f2
);
1085 if (priority1
< priority2
)
1087 else if (priority1
> priority2
)
1090 /* Ensure a stable sort. Constructors are executed in backwarding
1091 order to make LTO initialize braries first. */
1092 return DECL_UID (f2
) - DECL_UID (f1
);
1095 /* Comparison function for qsort. P1 and P2 are actually of type
1096 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
1097 used to determine the sort order. */
1100 compare_dtor (const void *p1
, const void *p2
)
1107 f1
= *(const tree
*)p1
;
1108 f2
= *(const tree
*)p2
;
1109 priority1
= DECL_FINI_PRIORITY (f1
);
1110 priority2
= DECL_FINI_PRIORITY (f2
);
1112 if (priority1
< priority2
)
1114 else if (priority1
> priority2
)
1117 /* Ensure a stable sort. */
1118 return DECL_UID (f1
) - DECL_UID (f2
);
1121 /* Generate functions to call static constructors and destructors
1122 for targets that do not support .ctors/.dtors sections. These
1123 functions have magic names which are detected by collect2. */
1126 build_cdtor_fns (void)
1128 if (!static_ctors
.is_empty ())
1130 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1131 static_ctors
.qsort (compare_ctor
);
1132 build_cdtor (/*ctor_p=*/true, static_ctors
);
1135 if (!static_dtors
.is_empty ())
1137 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1138 static_dtors
.qsort (compare_dtor
);
1139 build_cdtor (/*ctor_p=*/false, static_dtors
);
1143 /* Look for constructors and destructors and produce function calling them.
1144 This is needed for targets not supporting ctors or dtors, but we perform the
1145 transformation also at linktime to merge possibly numerous
1146 constructors/destructors into single function to improve code locality and
1150 ipa_cdtor_merge (void)
1152 struct cgraph_node
*node
;
1153 FOR_EACH_DEFINED_FUNCTION (node
)
1154 if (DECL_STATIC_CONSTRUCTOR (node
->decl
)
1155 || DECL_STATIC_DESTRUCTOR (node
->decl
))
1156 record_cdtor_fn (node
);
1158 static_ctors
.release ();
1159 static_dtors
.release ();
1163 static const pass_data pass_data_ipa_cdtor_merge
=
1165 IPA_PASS
, /* type */
1167 OPTGROUP_NONE
, /* optinfo_flags */
1168 TV_CGRAPHOPT
, /* tv_id */
1169 0, /* properties_required */
1170 0, /* properties_provided */
1171 0, /* properties_destroyed */
1172 0, /* todo_flags_start */
1173 0, /* todo_flags_finish */
1176 class pass_ipa_cdtor_merge GCC_FINAL
: public ipa_opt_pass_d
1179 pass_ipa_cdtor_merge (gcc::context
*ctxt
)
1180 : ipa_opt_pass_d (pass_data_ipa_cdtor_merge
, ctxt
,
1181 NULL
, /* generate_summary */
1182 NULL
, /* write_summary */
1183 NULL
, /* read_summary */
1184 NULL
, /* write_optimization_summary */
1185 NULL
, /* read_optimization_summary */
1186 NULL
, /* stmt_fixup */
1187 0, /* function_transform_todo_flags_start */
1188 NULL
, /* function_transform */
1189 NULL
) /* variable_transform */
1192 /* opt_pass methods: */
1193 virtual bool gate (function
*);
1194 virtual unsigned int execute (function
*) { return ipa_cdtor_merge (); }
1196 }; // class pass_ipa_cdtor_merge
1199 pass_ipa_cdtor_merge::gate (function
*)
1201 /* Perform the pass when we have no ctors/dtors support
1202 or at LTO time to merge multiple constructors into single
1204 return !targetm
.have_ctors_dtors
|| (optimize
&& in_lto_p
);
1208 make_pass_ipa_cdtor_merge (gcc::context
*ctxt
)
1210 return new pass_ipa_cdtor_merge (ctxt
);
1213 /* Invalid pointer representing BOTTOM for single user dataflow. */
1214 #define BOTTOM ((cgraph_node *)(size_t) 2)
1216 /* Meet operation for single user dataflow.
1217 Here we want to associate variables with sigle function that may access it.
1219 FUNCTION is current single user of a variable, VAR is variable that uses it.
1220 Latttice is stored in SINGLE_USER_MAP.
1223 - TOP by no entry in SIGNLE_USER_MAP
1224 - BOTTOM by BOTTOM in AUX pointer (to save lookups)
1225 - known single user by cgraph pointer in SINGLE_USER_MAP. */
1228 meet (cgraph_node
*function
, varpool_node
*var
,
1229 hash_map
<varpool_node
*, cgraph_node
*> &single_user_map
)
1231 struct cgraph_node
*user
, **f
;
1233 if (var
->aux
== BOTTOM
)
1236 f
= single_user_map
.get (var
);
1242 else if (function
!= user
)
1248 /* Propagation step of single-use dataflow.
1250 Check all uses of VNODE and see if they are used by single function FUNCTION.
1251 SINGLE_USER_MAP represents the dataflow lattice. */
1254 propagate_single_user (varpool_node
*vnode
, cgraph_node
*function
,
1255 hash_map
<varpool_node
*, cgraph_node
*> &single_user_map
)
1258 struct ipa_ref
*ref
;
1260 gcc_assert (!vnode
->externally_visible
);
1262 /* If node is an alias, first meet with its target. */
1264 function
= meet (function
, vnode
->get_alias_target (), single_user_map
);
1266 /* Check all users and see if they correspond to a single function. */
1267 for (i
= 0; vnode
->iterate_referring (i
, ref
) && function
!= BOTTOM
; i
++)
1269 struct cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (ref
->referring
);
1272 if (cnode
->global
.inlined_to
)
1273 cnode
= cnode
->global
.inlined_to
;
1276 else if (function
!= cnode
)
1280 function
= meet (function
, dyn_cast
<varpool_node
*> (ref
->referring
),
1286 /* Pass setting used_by_single_function flag.
1287 This flag is set on variable when there is only one function that may
1288 possibly referr to it. */
1291 ipa_single_use (void)
1293 varpool_node
*first
= (varpool_node
*) (void *) 1;
1295 hash_map
<varpool_node
*, cgraph_node
*> single_user_map
;
1297 FOR_EACH_DEFINED_VARIABLE (var
)
1298 if (!var
->all_refs_explicit_p ())
1302 /* Enqueue symbol for dataflow. */
1307 /* The actual dataflow. */
1309 while (first
!= (void *) 1)
1311 cgraph_node
*user
, *orig_user
, **f
;
1314 first
= (varpool_node
*)first
->aux
;
1316 f
= single_user_map
.get (var
);
1321 user
= propagate_single_user (var
, orig_user
, single_user_map
);
1323 gcc_checking_assert (var
->aux
!= BOTTOM
);
1325 /* If user differs, enqueue all references. */
1326 if (user
!= orig_user
)
1331 single_user_map
.put (var
, user
);
1333 /* Enqueue all aliases for re-processing. */
1334 for (i
= 0; var
->iterate_direct_aliases (i
, ref
); i
++)
1335 if (!ref
->referring
->aux
)
1337 ref
->referring
->aux
= first
;
1338 first
= dyn_cast
<varpool_node
*> (ref
->referring
);
1340 /* Enqueue all users for re-processing. */
1341 for (i
= 0; var
->iterate_reference (i
, ref
); i
++)
1342 if (!ref
->referred
->aux
1343 && ref
->referred
->definition
1344 && is_a
<varpool_node
*> (ref
->referred
))
1346 ref
->referred
->aux
= first
;
1347 first
= dyn_cast
<varpool_node
*> (ref
->referred
);
1350 /* If user is BOTTOM, just punt on this var. */
1360 FOR_EACH_DEFINED_VARIABLE (var
)
1362 if (var
->aux
!= BOTTOM
)
1364 #ifdef ENABLE_CHECKING
1365 /* Not having the single user known means that the VAR is
1366 unreachable. Either someone forgot to remove unreachable
1367 variables or the reachability here is wrong. */
1369 gcc_assert (single_user_map
.get (var
));
1373 fprintf (dump_file
, "Variable %s/%i is used by single function\n",
1374 var
->name (), var
->order
);
1376 var
->used_by_single_function
= true;
1383 static const pass_data pass_data_ipa_single_use
=
1385 IPA_PASS
, /* type */
1386 "single-use", /* name */
1387 OPTGROUP_NONE
, /* optinfo_flags */
1388 TV_CGRAPHOPT
, /* tv_id */
1389 0, /* properties_required */
1390 0, /* properties_provided */
1391 0, /* properties_destroyed */
1392 0, /* todo_flags_start */
1393 0, /* todo_flags_finish */
1396 class pass_ipa_single_use GCC_FINAL
: public ipa_opt_pass_d
1399 pass_ipa_single_use (gcc::context
*ctxt
)
1400 : ipa_opt_pass_d (pass_data_ipa_single_use
, ctxt
,
1401 NULL
, /* generate_summary */
1402 NULL
, /* write_summary */
1403 NULL
, /* read_summary */
1404 NULL
, /* write_optimization_summary */
1405 NULL
, /* read_optimization_summary */
1406 NULL
, /* stmt_fixup */
1407 0, /* function_transform_todo_flags_start */
1408 NULL
, /* function_transform */
1409 NULL
) /* variable_transform */
1412 /* opt_pass methods: */
1413 virtual bool gate (function
*);
1414 virtual unsigned int execute (function
*) { return ipa_single_use (); }
1416 }; // class pass_ipa_single_use
1419 pass_ipa_single_use::gate (function
*)
1425 make_pass_ipa_single_use (gcc::context
*ctxt
)
1427 return new pass_ipa_single_use (ctxt
);