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:");
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;
337 && !node
->global
.inlined_to
338 && !node
->in_other_partition
339 && !node
->can_remove_if_no_direct_calls_and_refs_p ())
341 gcc_assert (!node
->global
.inlined_to
);
342 reachable
.add (node
);
343 enqueue_node (node
, &first
, &reachable
);
346 gcc_assert (!node
->aux
);
349 /* Mark variables that are obviously needed. */
350 FOR_EACH_DEFINED_VARIABLE (vnode
)
351 if (!vnode
->can_remove_if_no_refs_p()
352 && !vnode
->in_other_partition
)
354 reachable
.add (vnode
);
355 enqueue_node (vnode
, &first
, &reachable
);
358 /* Perform reachability analysis. */
359 while (first
!= (symtab_node
*) (void *) 1)
361 bool in_boundary_p
= !reachable
.contains (first
);
362 symtab_node
*node
= first
;
364 first
= (symtab_node
*)first
->aux
;
366 /* If we are processing symbol in boundary, mark its AUX pointer for
367 possible later re-processing in enqueue_node. */
370 node
->aux
= (void *)2;
371 if (node
->alias
&& node
->analyzed
)
372 enqueue_node (node
->get_alias_target (), &first
, &reachable
);
376 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
377 && DECL_ABSTRACT_ORIGIN (node
->decl
))
379 struct cgraph_node
*origin_node
380 = cgraph_node::get (DECL_ABSTRACT_ORIGIN (node
->decl
));
381 if (origin_node
&& !origin_node
->used_as_abstract_origin
)
383 origin_node
->used_as_abstract_origin
= true;
384 gcc_assert (!origin_node
->prev_sibling_clone
);
385 gcc_assert (!origin_node
->next_sibling_clone
);
386 for (cgraph_node
*n
= origin_node
->clones
; n
;
387 n
= n
->next_sibling_clone
)
388 if (n
->decl
== DECL_ABSTRACT_ORIGIN (node
->decl
))
389 n
->used_as_abstract_origin
= true;
392 /* If any symbol in a comdat group is reachable, force
393 all externally visible symbols in the same comdat
394 group to be reachable as well. Comdat-local symbols
395 can be discarded if all uses were inlined. */
396 if (node
->same_comdat_group
)
399 for (next
= node
->same_comdat_group
;
401 next
= next
->same_comdat_group
)
402 if (!next
->comdat_local_p ()
403 && !reachable
.add (next
))
404 enqueue_node (next
, &first
, &reachable
);
406 /* Mark references as reachable. */
407 process_references (node
, &first
, before_inlining_p
, &reachable
);
410 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
))
412 /* Mark the callees reachable unless they are direct calls to extern
413 inline functions we decided to not inline. */
416 struct cgraph_edge
*e
;
417 /* Keep alive possible targets for devirtualization. */
418 if (opt_for_fn (cnode
->decl
, optimize
)
419 && opt_for_fn (cnode
->decl
, flag_devirtualize
))
421 struct cgraph_edge
*next
;
422 for (e
= cnode
->indirect_calls
; e
; e
= next
)
424 next
= e
->next_callee
;
425 if (e
->indirect_info
->polymorphic
)
426 walk_polymorphic_call_targets (&reachable_call_targets
,
427 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 || (before_inlining_p
440 && (opt_for_fn (body
->decl
, optimize
)
441 || (symtab
->state
< IPA_SSA
444 DECL_ATTRIBUTES (body
->decl
)))))))
446 /* Be sure that we will not optimize out alias target
448 if (DECL_EXTERNAL (e
->callee
->decl
)
450 && before_inlining_p
)
451 reachable
.add (body
);
452 reachable
.add (e
->callee
);
454 enqueue_node (e
->callee
, &first
, &reachable
);
457 /* When inline clone exists, mark body to be preserved so when removing
458 offline copy of the function we don't kill it. */
459 if (cnode
->global
.inlined_to
)
460 body_needed_for_clonning
.add (cnode
->decl
);
462 /* For instrumentation clones we always need original
463 function node for proper LTO privatization. */
464 if (cnode
->instrumentation_clone
465 && cnode
->definition
)
467 gcc_assert (cnode
->instrumented_version
|| in_lto_p
);
468 if (cnode
->instrumented_version
)
470 enqueue_node (cnode
->instrumented_version
, &first
,
472 reachable
.add (cnode
->instrumented_version
);
476 /* For non-inline clones, force their origins to the boundary and ensure
477 that body is not removed. */
478 while (cnode
->clone_of
)
480 bool noninline
= cnode
->clone_of
->decl
!= cnode
->decl
;
481 cnode
= cnode
->clone_of
;
484 body_needed_for_clonning
.add (cnode
->decl
);
485 enqueue_node (cnode
, &first
, &reachable
);
490 else if (cnode
->thunk
.thunk_p
)
491 enqueue_node (cnode
->callees
->callee
, &first
, &reachable
);
493 /* If any reachable function has simd clones, mark them as
494 reachable as well. */
495 if (cnode
->simd_clones
)
498 for (next
= cnode
->simd_clones
;
500 next
= next
->simdclone
->next_clone
)
502 || !reachable
.add (next
))
503 enqueue_node (next
, &first
, &reachable
);
506 /* When we see constructor of external variable, keep referred nodes in the
507 boundary. This will also hold initializers of the external vars NODE
509 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
511 && DECL_EXTERNAL (node
->decl
)
515 struct ipa_ref
*ref
= NULL
;
516 for (int i
= 0; node
->iterate_reference (i
, ref
); i
++)
517 enqueue_node (ref
->referred
, &first
, &reachable
);
521 /* Remove unreachable functions. */
522 for (node
= first_function (); node
; node
= next
)
524 next
= next_function (node
);
526 /* If node is not needed at all, remove it. */
530 fprintf (file
, " %s/%i", node
->name (), node
->order
);
534 /* If node is unreachable, remove its body. */
535 else if (!reachable
.contains (node
))
537 /* We keep definitions of thunks and aliases in the boundary so
538 we can walk to the ultimate alias targets and function symbols
540 if (node
->alias
|| node
->thunk
.thunk_p
)
542 else if (!body_needed_for_clonning
.contains (node
->decl
)
543 && !node
->alias
&& !node
->thunk
.thunk_p
)
544 node
->release_body ();
545 else if (!node
->clone_of
)
546 gcc_assert (in_lto_p
|| DECL_RESULT (node
->decl
));
547 if (node
->definition
&& !node
->alias
&& !node
->thunk
.thunk_p
)
550 fprintf (file
, " %s/%i", node
->name (), node
->order
);
551 node
->body_removed
= true;
552 node
->analyzed
= false;
553 node
->definition
= false;
554 node
->cpp_implicit_alias
= false;
556 node
->thunk
.thunk_p
= false;
557 node
->weakref
= false;
558 /* After early inlining we drop always_inline attributes on
559 bodies of functions that are still referenced (have their
561 DECL_ATTRIBUTES (node
->decl
)
562 = remove_attribute ("always_inline",
563 DECL_ATTRIBUTES (node
->decl
));
564 if (!node
->in_other_partition
)
565 node
->local
.local
= false;
566 node
->remove_callees ();
567 node
->remove_all_references ();
569 if (node
->thunk
.thunk_p
570 && node
->thunk
.add_pointer_bounds_args
)
572 node
->thunk
.thunk_p
= false;
573 node
->thunk
.add_pointer_bounds_args
= false;
578 gcc_assert (node
->clone_of
|| !node
->has_gimple_body_p ()
579 || in_lto_p
|| DECL_RESULT (node
->decl
));
582 /* Inline clones might be kept around so their materializing allows further
583 cloning. If the function the clone is inlined into is removed, we need
584 to turn it into normal cone. */
585 FOR_EACH_FUNCTION (node
)
587 if (node
->global
.inlined_to
590 gcc_assert (node
->clones
);
591 node
->global
.inlined_to
= NULL
;
592 update_inlined_to_pointer (node
, node
);
597 /* Remove unreachable variables. */
599 fprintf (file
, "\nReclaiming variables:");
600 for (vnode
= first_variable (); vnode
; vnode
= vnext
)
602 vnext
= next_variable (vnode
);
604 /* For can_refer_decl_in_current_unit_p we want to track for
605 all external variables if they are defined in other partition
607 && (!flag_ltrans
|| !DECL_EXTERNAL (vnode
->decl
)))
609 struct ipa_ref
*ref
= NULL
;
611 /* First remove the aliases, so varpool::remove can possibly lookup
612 the constructor and save it for future use. */
613 while (vnode
->iterate_direct_aliases (0, ref
))
616 fprintf (file
, " %s/%i", ref
->referred
->name (),
617 ref
->referred
->order
);
618 ref
->referring
->remove ();
621 fprintf (file
, " %s/%i", vnode
->name (), vnode
->order
);
622 vnext
= next_variable (vnode
);
626 else if (!reachable
.contains (vnode
) && !vnode
->alias
)
629 if (vnode
->definition
)
632 fprintf (file
, " %s", vnode
->name ());
635 /* Keep body if it may be useful for constant folding. */
636 if ((init
= ctor_for_folding (vnode
->decl
)) == error_mark_node
637 && !POINTER_BOUNDS_P (vnode
->decl
))
638 vnode
->remove_initializer ();
640 DECL_INITIAL (vnode
->decl
) = init
;
641 vnode
->body_removed
= true;
642 vnode
->definition
= false;
643 vnode
->analyzed
= false;
646 vnode
->remove_from_same_comdat_group ();
648 vnode
->remove_all_references ();
654 /* Now update address_taken flags and try to promote functions to be local. */
656 fprintf (file
, "\nClearing address taken flags:");
657 FOR_EACH_DEFINED_FUNCTION (node
)
658 if (node
->address_taken
659 && !node
->used_from_other_partition
)
661 if (!node
->call_for_symbol_and_aliases
662 (has_addr_references_p
, NULL
, true)
663 && (!node
->instrumentation_clone
664 || !node
->instrumented_version
665 || !node
->instrumented_version
->address_taken
))
668 fprintf (file
, " %s", node
->name ());
669 node
->address_taken
= false;
671 if (node
->local_p ())
673 node
->local
.local
= true;
675 fprintf (file
, " (local)");
680 fprintf (file
, "\n");
682 symtab_node::checking_verify_symtab_nodes ();
684 /* If we removed something, perhaps profile could be improved. */
685 if (changed
&& optimize
&& inline_edge_summary_vec
.exists ())
686 FOR_EACH_DEFINED_FUNCTION (node
)
687 ipa_propagate_frequency (node
);
689 timevar_pop (TV_IPA_UNREACHABLE
);
693 /* Process references to VNODE and set flags WRITTEN, ADDRESS_TAKEN, READ
694 as needed, also clear EXPLICIT_REFS if the references to given variable
695 do not need to be explicit. */
698 process_references (varpool_node
*vnode
,
699 bool *written
, bool *address_taken
,
700 bool *read
, bool *explicit_refs
)
705 if (!vnode
->all_refs_explicit_p ()
706 || TREE_THIS_VOLATILE (vnode
->decl
))
707 *explicit_refs
= false;
709 for (i
= 0; vnode
->iterate_referring (i
, ref
)
710 && *explicit_refs
&& (!*written
|| !*address_taken
|| !*read
); i
++)
714 *address_taken
= true;
723 process_references (dyn_cast
<varpool_node
*> (ref
->referring
), written
,
724 address_taken
, read
, explicit_refs
);
731 /* Set TREE_READONLY bit. */
734 set_readonly_bit (varpool_node
*vnode
, void *data ATTRIBUTE_UNUSED
)
736 TREE_READONLY (vnode
->decl
) = true;
740 /* Set writeonly bit and clear the initalizer, since it will not be needed. */
743 set_writeonly_bit (varpool_node
*vnode
, void *data
)
745 vnode
->writeonly
= true;
748 DECL_INITIAL (vnode
->decl
) = NULL
;
751 if (vnode
->num_references ())
752 *(bool *)data
= true;
753 vnode
->remove_all_references ();
759 /* Clear addressale bit of VNODE. */
762 clear_addressable_bit (varpool_node
*vnode
, void *data ATTRIBUTE_UNUSED
)
764 vnode
->address_taken
= false;
765 TREE_ADDRESSABLE (vnode
->decl
) = 0;
769 /* Discover variables that have no longer address taken or that are read only
770 and update their flags.
772 Return true when unreachable symbol removan should be done.
774 FIXME: This can not be done in between gimplify and omp_expand since
775 readonly flag plays role on what is shared and what is not. Currently we do
776 this transformation as part of whole program visibility and re-do at
777 ipa-reference pass (to take into account clonning), but it would
778 make sense to do it before early optimizations. */
781 ipa_discover_readonly_nonaddressable_vars (void)
783 bool remove_p
= false;
786 fprintf (dump_file
, "Clearing variable flags:");
787 FOR_EACH_VARIABLE (vnode
)
789 && (TREE_ADDRESSABLE (vnode
->decl
)
791 || !TREE_READONLY (vnode
->decl
)))
793 bool written
= false;
794 bool address_taken
= false;
796 bool explicit_refs
= true;
798 process_references (vnode
, &written
, &address_taken
, &read
,
804 if (TREE_ADDRESSABLE (vnode
->decl
) && dump_file
)
805 fprintf (dump_file
, " %s (non-addressable)", vnode
->name ());
806 vnode
->call_for_symbol_and_aliases (clear_addressable_bit
, NULL
,
809 if (!address_taken
&& !written
810 /* Making variable in explicit section readonly can cause section
812 See e.g. gcc.c-torture/compile/pr23237.c */
813 && vnode
->get_section () == NULL
)
815 if (!TREE_READONLY (vnode
->decl
) && dump_file
)
816 fprintf (dump_file
, " %s (read-only)", vnode
->name ());
817 vnode
->call_for_symbol_and_aliases (set_readonly_bit
, NULL
, true);
819 if (!vnode
->writeonly
&& !read
&& !address_taken
&& written
)
822 fprintf (dump_file
, " %s (write-only)", vnode
->name ());
823 vnode
->call_for_symbol_and_aliases (set_writeonly_bit
, &remove_p
,
828 fprintf (dump_file
, "\n");
832 /* Free inline summary. */
836 const pass_data pass_data_ipa_free_inline_summary
=
838 SIMPLE_IPA_PASS
, /* type */
839 "free-inline-summary", /* name */
840 OPTGROUP_NONE
, /* optinfo_flags */
841 TV_IPA_FREE_INLINE_SUMMARY
, /* tv_id */
842 0, /* properties_required */
843 0, /* properties_provided */
844 0, /* properties_destroyed */
845 0, /* todo_flags_start */
846 /* Early optimizations may make function unreachable. We can not
847 remove unreachable functions as part of the ealry opts pass because
848 TODOs are run before subpasses. Do it here. */
849 ( TODO_remove_functions
| TODO_dump_symtab
), /* todo_flags_finish */
852 class pass_ipa_free_inline_summary
: public simple_ipa_opt_pass
855 pass_ipa_free_inline_summary (gcc::context
*ctxt
)
856 : simple_ipa_opt_pass (pass_data_ipa_free_inline_summary
, ctxt
)
859 /* opt_pass methods: */
860 virtual unsigned int execute (function
*)
862 inline_free_summary ();
866 }; // class pass_ipa_free_inline_summary
870 simple_ipa_opt_pass
*
871 make_pass_ipa_free_inline_summary (gcc::context
*ctxt
)
873 return new pass_ipa_free_inline_summary (ctxt
);
876 /* Generate and emit a static constructor or destructor. WHICH must
877 be one of 'I' (for a constructor), 'D' (for a destructor), 'P'
878 (for chp static vars constructor) or 'B' (for chkp static bounds
879 constructor). BODY is a STATEMENT_LIST containing GENERIC
880 statements. PRIORITY is the initialization priority for this
881 constructor or destructor.
883 FINAL specify whether the externally visible name for collect2 should
887 cgraph_build_static_cdtor_1 (char which
, tree body
, int priority
, bool final
)
889 static int counter
= 0;
891 tree decl
, name
, resdecl
;
893 /* The priority is encoded in the constructor or destructor name.
894 collect2 will sort the names and arrange that they are called at
897 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
899 /* Proudce sane name but one not recognizable by collect2, just for the
900 case we fail to inline the function. */
901 sprintf (which_buf
, "sub_%c_%.5d_%d", which
, priority
, counter
++);
902 name
= get_file_function_name (which_buf
);
904 decl
= build_decl (input_location
, FUNCTION_DECL
, name
,
905 build_function_type_list (void_type_node
, NULL_TREE
));
906 current_function_decl
= decl
;
908 resdecl
= build_decl (input_location
,
909 RESULT_DECL
, NULL_TREE
, void_type_node
);
910 DECL_ARTIFICIAL (resdecl
) = 1;
911 DECL_RESULT (decl
) = resdecl
;
912 DECL_CONTEXT (resdecl
) = decl
;
914 allocate_struct_function (decl
, false);
916 TREE_STATIC (decl
) = 1;
917 TREE_USED (decl
) = 1;
918 DECL_ARTIFICIAL (decl
) = 1;
919 DECL_IGNORED_P (decl
) = 1;
920 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
921 DECL_SAVED_TREE (decl
) = body
;
922 if (!targetm
.have_ctors_dtors
&& final
)
924 TREE_PUBLIC (decl
) = 1;
925 DECL_PRESERVE_P (decl
) = 1;
927 DECL_UNINLINABLE (decl
) = 1;
929 DECL_INITIAL (decl
) = make_node (BLOCK
);
930 TREE_USED (DECL_INITIAL (decl
)) = 1;
932 DECL_SOURCE_LOCATION (decl
) = input_location
;
933 cfun
->function_end_locus
= input_location
;
938 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
939 decl_init_priority_insert (decl
, priority
);
942 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
943 DECL_ATTRIBUTES (decl
) = tree_cons (get_identifier ("chkp ctor"),
946 decl_init_priority_insert (decl
, priority
);
949 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
950 DECL_ATTRIBUTES (decl
) = tree_cons (get_identifier ("bnd_legacy"),
953 decl_init_priority_insert (decl
, priority
);
956 DECL_STATIC_DESTRUCTOR (decl
) = 1;
957 decl_fini_priority_insert (decl
, priority
);
963 gimplify_function_tree (decl
);
965 cgraph_node::add_new_function (decl
, false);
968 current_function_decl
= NULL
;
971 /* Generate and emit a static constructor or destructor. WHICH must
972 be one of 'I' (for a constructor), 'D' (for a destructor), 'P'
973 (for chkp static vars constructor) or 'B' (for chkp static bounds
974 constructor). BODY is a STATEMENT_LIST containing GENERIC
975 statements. PRIORITY is the initialization priority for this
976 constructor or destructor. */
979 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
981 cgraph_build_static_cdtor_1 (which
, body
, priority
, false);
984 /* A vector of FUNCTION_DECLs declared as static constructors. */
985 static vec
<tree
> static_ctors
;
986 /* A vector of FUNCTION_DECLs declared as static destructors. */
987 static vec
<tree
> static_dtors
;
989 /* When target does not have ctors and dtors, we call all constructor
990 and destructor by special initialization/destruction function
991 recognized by collect2.
993 When we are going to build this function, collect all constructors and
994 destructors and turn them into normal functions. */
997 record_cdtor_fn (struct cgraph_node
*node
)
999 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
1000 static_ctors
.safe_push (node
->decl
);
1001 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
1002 static_dtors
.safe_push (node
->decl
);
1003 node
= cgraph_node::get (node
->decl
);
1004 DECL_DISREGARD_INLINE_LIMITS (node
->decl
) = 1;
1007 /* Define global constructors/destructor functions for the CDTORS, of
1008 which they are LEN. The CDTORS are sorted by initialization
1009 priority. If CTOR_P is true, these are constructors; otherwise,
1010 they are destructors. */
1013 build_cdtor (bool ctor_p
, vec
<tree
> cdtors
)
1016 size_t len
= cdtors
.length ();
1023 priority_type priority
;
1032 p
= ctor_p
? DECL_INIT_PRIORITY (fn
) : DECL_FINI_PRIORITY (fn
);
1035 else if (p
!= priority
)
1041 /* When there is only one cdtor and target supports them, do nothing. */
1043 && targetm
.have_ctors_dtors
)
1048 /* Find the next batch of constructors/destructors with the same
1049 initialization priority. */
1054 call
= build_call_expr (fn
, 0);
1056 DECL_STATIC_CONSTRUCTOR (fn
) = 0;
1058 DECL_STATIC_DESTRUCTOR (fn
) = 0;
1059 /* We do not want to optimize away pure/const calls here.
1060 When optimizing, these should be already removed, when not
1061 optimizing, we want user to be able to breakpoint in them. */
1062 TREE_SIDE_EFFECTS (call
) = 1;
1063 append_to_statement_list (call
, &body
);
1065 gcc_assert (body
!= NULL_TREE
);
1066 /* Generate a function to call all the function of like
1068 cgraph_build_static_cdtor_1 (ctor_p
? 'I' : 'D', body
, priority
, true);
1072 /* Comparison function for qsort. P1 and P2 are actually of type
1073 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
1074 used to determine the sort order. */
1077 compare_ctor (const void *p1
, const void *p2
)
1084 f1
= *(const tree
*)p1
;
1085 f2
= *(const tree
*)p2
;
1086 priority1
= DECL_INIT_PRIORITY (f1
);
1087 priority2
= DECL_INIT_PRIORITY (f2
);
1089 if (priority1
< priority2
)
1091 else if (priority1
> priority2
)
1094 /* Ensure a stable sort. Constructors are executed in backwarding
1095 order to make LTO initialize braries first. */
1096 return DECL_UID (f2
) - DECL_UID (f1
);
1099 /* Comparison function for qsort. P1 and P2 are actually of type
1100 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
1101 used to determine the sort order. */
1104 compare_dtor (const void *p1
, const void *p2
)
1111 f1
= *(const tree
*)p1
;
1112 f2
= *(const tree
*)p2
;
1113 priority1
= DECL_FINI_PRIORITY (f1
);
1114 priority2
= DECL_FINI_PRIORITY (f2
);
1116 if (priority1
< priority2
)
1118 else if (priority1
> priority2
)
1121 /* Ensure a stable sort. */
1122 return DECL_UID (f1
) - DECL_UID (f2
);
1125 /* Generate functions to call static constructors and destructors
1126 for targets that do not support .ctors/.dtors sections. These
1127 functions have magic names which are detected by collect2. */
1130 build_cdtor_fns (void)
1132 if (!static_ctors
.is_empty ())
1134 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1135 static_ctors
.qsort (compare_ctor
);
1136 build_cdtor (/*ctor_p=*/true, static_ctors
);
1139 if (!static_dtors
.is_empty ())
1141 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1142 static_dtors
.qsort (compare_dtor
);
1143 build_cdtor (/*ctor_p=*/false, static_dtors
);
1147 /* Look for constructors and destructors and produce function calling them.
1148 This is needed for targets not supporting ctors or dtors, but we perform the
1149 transformation also at linktime to merge possibly numerous
1150 constructors/destructors into single function to improve code locality and
1154 ipa_cdtor_merge (void)
1156 struct cgraph_node
*node
;
1157 FOR_EACH_DEFINED_FUNCTION (node
)
1158 if (DECL_STATIC_CONSTRUCTOR (node
->decl
)
1159 || DECL_STATIC_DESTRUCTOR (node
->decl
))
1160 record_cdtor_fn (node
);
1162 static_ctors
.release ();
1163 static_dtors
.release ();
1169 const pass_data pass_data_ipa_cdtor_merge
=
1171 IPA_PASS
, /* type */
1173 OPTGROUP_NONE
, /* optinfo_flags */
1174 TV_CGRAPHOPT
, /* tv_id */
1175 0, /* properties_required */
1176 0, /* properties_provided */
1177 0, /* properties_destroyed */
1178 0, /* todo_flags_start */
1179 0, /* todo_flags_finish */
1182 class pass_ipa_cdtor_merge
: public ipa_opt_pass_d
1185 pass_ipa_cdtor_merge (gcc::context
*ctxt
)
1186 : ipa_opt_pass_d (pass_data_ipa_cdtor_merge
, ctxt
,
1187 NULL
, /* generate_summary */
1188 NULL
, /* write_summary */
1189 NULL
, /* read_summary */
1190 NULL
, /* write_optimization_summary */
1191 NULL
, /* read_optimization_summary */
1192 NULL
, /* stmt_fixup */
1193 0, /* function_transform_todo_flags_start */
1194 NULL
, /* function_transform */
1195 NULL
) /* variable_transform */
1198 /* opt_pass methods: */
1199 virtual bool gate (function
*);
1200 virtual unsigned int execute (function
*) { return ipa_cdtor_merge (); }
1202 }; // class pass_ipa_cdtor_merge
1205 pass_ipa_cdtor_merge::gate (function
*)
1207 /* Perform the pass when we have no ctors/dtors support
1208 or at LTO time to merge multiple constructors into single
1210 return !targetm
.have_ctors_dtors
|| (optimize
&& in_lto_p
);
1216 make_pass_ipa_cdtor_merge (gcc::context
*ctxt
)
1218 return new pass_ipa_cdtor_merge (ctxt
);
1221 /* Invalid pointer representing BOTTOM for single user dataflow. */
1222 #define BOTTOM ((cgraph_node *)(size_t) 2)
1224 /* Meet operation for single user dataflow.
1225 Here we want to associate variables with sigle function that may access it.
1227 FUNCTION is current single user of a variable, VAR is variable that uses it.
1228 Latttice is stored in SINGLE_USER_MAP.
1231 - TOP by no entry in SIGNLE_USER_MAP
1232 - BOTTOM by BOTTOM in AUX pointer (to save lookups)
1233 - known single user by cgraph pointer in SINGLE_USER_MAP. */
1236 meet (cgraph_node
*function
, varpool_node
*var
,
1237 hash_map
<varpool_node
*, cgraph_node
*> &single_user_map
)
1239 struct cgraph_node
*user
, **f
;
1241 if (var
->aux
== BOTTOM
)
1244 f
= single_user_map
.get (var
);
1250 else if (function
!= user
)
1256 /* Propagation step of single-use dataflow.
1258 Check all uses of VNODE and see if they are used by single function FUNCTION.
1259 SINGLE_USER_MAP represents the dataflow lattice. */
1262 propagate_single_user (varpool_node
*vnode
, cgraph_node
*function
,
1263 hash_map
<varpool_node
*, cgraph_node
*> &single_user_map
)
1266 struct ipa_ref
*ref
;
1268 gcc_assert (!vnode
->externally_visible
);
1270 /* If node is an alias, first meet with its target. */
1272 function
= meet (function
, vnode
->get_alias_target (), single_user_map
);
1274 /* Check all users and see if they correspond to a single function. */
1275 for (i
= 0; vnode
->iterate_referring (i
, ref
) && function
!= BOTTOM
; i
++)
1277 struct cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (ref
->referring
);
1280 if (cnode
->global
.inlined_to
)
1281 cnode
= cnode
->global
.inlined_to
;
1284 else if (function
!= cnode
)
1288 function
= meet (function
, dyn_cast
<varpool_node
*> (ref
->referring
),
1294 /* Pass setting used_by_single_function flag.
1295 This flag is set on variable when there is only one function that may
1296 possibly referr to it. */
1299 ipa_single_use (void)
1301 varpool_node
*first
= (varpool_node
*) (void *) 1;
1303 hash_map
<varpool_node
*, cgraph_node
*> single_user_map
;
1305 FOR_EACH_DEFINED_VARIABLE (var
)
1306 if (!var
->all_refs_explicit_p ())
1310 /* Enqueue symbol for dataflow. */
1315 /* The actual dataflow. */
1317 while (first
!= (void *) 1)
1319 cgraph_node
*user
, *orig_user
, **f
;
1322 first
= (varpool_node
*)first
->aux
;
1324 f
= single_user_map
.get (var
);
1329 user
= propagate_single_user (var
, orig_user
, single_user_map
);
1331 gcc_checking_assert (var
->aux
!= BOTTOM
);
1333 /* If user differs, enqueue all references. */
1334 if (user
!= orig_user
)
1339 single_user_map
.put (var
, user
);
1341 /* Enqueue all aliases for re-processing. */
1342 for (i
= 0; var
->iterate_direct_aliases (i
, ref
); i
++)
1343 if (!ref
->referring
->aux
)
1345 ref
->referring
->aux
= first
;
1346 first
= dyn_cast
<varpool_node
*> (ref
->referring
);
1348 /* Enqueue all users for re-processing. */
1349 for (i
= 0; var
->iterate_reference (i
, ref
); i
++)
1350 if (!ref
->referred
->aux
1351 && ref
->referred
->definition
1352 && is_a
<varpool_node
*> (ref
->referred
))
1354 ref
->referred
->aux
= first
;
1355 first
= dyn_cast
<varpool_node
*> (ref
->referred
);
1358 /* If user is BOTTOM, just punt on this var. */
1368 FOR_EACH_DEFINED_VARIABLE (var
)
1370 if (var
->aux
!= BOTTOM
)
1372 /* Not having the single user known means that the VAR is
1373 unreachable. Either someone forgot to remove unreachable
1374 variables or the reachability here is wrong. */
1376 gcc_checking_assert (single_user_map
.get (var
));
1380 fprintf (dump_file
, "Variable %s/%i is used by single function\n",
1381 var
->name (), var
->order
);
1383 var
->used_by_single_function
= true;
1392 const pass_data pass_data_ipa_single_use
=
1394 IPA_PASS
, /* type */
1395 "single-use", /* name */
1396 OPTGROUP_NONE
, /* optinfo_flags */
1397 TV_CGRAPHOPT
, /* tv_id */
1398 0, /* properties_required */
1399 0, /* properties_provided */
1400 0, /* properties_destroyed */
1401 0, /* todo_flags_start */
1402 0, /* todo_flags_finish */
1405 class pass_ipa_single_use
: public ipa_opt_pass_d
1408 pass_ipa_single_use (gcc::context
*ctxt
)
1409 : ipa_opt_pass_d (pass_data_ipa_single_use
, ctxt
,
1410 NULL
, /* generate_summary */
1411 NULL
, /* write_summary */
1412 NULL
, /* read_summary */
1413 NULL
, /* write_optimization_summary */
1414 NULL
, /* read_optimization_summary */
1415 NULL
, /* stmt_fixup */
1416 0, /* function_transform_todo_flags_start */
1417 NULL
, /* function_transform */
1418 NULL
) /* variable_transform */
1421 /* opt_pass methods: */
1422 virtual bool gate (function
*);
1423 virtual unsigned int execute (function
*) { return ipa_single_use (); }
1425 }; // class pass_ipa_single_use
1428 pass_ipa_single_use::gate (function
*)
1436 make_pass_ipa_single_use (gcc::context
*ctxt
)
1438 return new pass_ipa_single_use (ctxt
);